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

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 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 "deRandom.hpp"
  28 #include "deStringUtil.hpp"
  29 #include "deUniquePtr.hpp"
  30 #include "vkImageUtil.hpp"
  31 #include "vkMemUtil.hpp"
  32 #include "vktTestCase.hpp"
  33 #include "vktTestCaseUtil.hpp"
  34 #include "vkQueryUtil.hpp"
  35 #include "vkRefUtil.hpp"
  36 #include "vkTypeUtil.hpp"
  37 #include "tcuImageCompare.hpp"
  38 #include "tcuTextureUtil.hpp"
  39 #include "tcuVectorType.hpp"
  40 #include "tcuTexture.hpp"
  41
  42 namespace vkt
  43 {
  44
  45 namespace api
  46 {
  47
  48 using namespace vk;
  49
  50 namespace
  51 {
  52
  53 union CopyRegion
  54 {
  55         VkBufferCopy            bufferCopy;
  56         VkImageCopy                     imageCopy;
  57         VkBufferImageCopy       bufferImageCopy;
  58         VkImageBlit                     imageBlit;
  59 };
  60
  61 struct TestParams
  62 {
  63         union Data
  64         {
  65                 struct Buffer
  66                 {
  67                         VkDeviceSize    size;
  68                 }       buffer;
  69                 struct Image
  70                 {
  71                         VkFormat                format;
  72                         VkExtent3D              extent;
  73                 }       image;
  74         }       src, dst;
  75
  76         std::vector<CopyRegion> regions;
  77 };
  78
  79 class CopiesAndBlittingTestInstance : public vkt::TestInstance
  80 {
  81 public:
  82                                                                                 CopiesAndBlittingTestInstance           (Context&       context,
  83                                                                                                                                                          TestParams     testParams);
  84         virtual                                                         ~CopiesAndBlittingTestInstance          (void);
  85         virtual tcu::TestStatus                         iterate                                                         (void) = 0;
  86         enum FillMode
  87         {
  88                 FILL_MODE_SEQUENTIAL = 0,
  89                 FILL_MODE_RANDOM,
  90                 FILL_MODE_WHITE,
  91                 FILL_MODE_RED,
  92
  93                 FILL_MODE_LAST
  94         };
  95 protected:
  96         const TestParams                                        m_params;
  97
  98         Move<VkCommandPool>                                     m_cmdPool;
  99         Move<VkCommandBuffer>                           m_cmdBuffer;
 100         Move<VkFence>                                           m_fence;
 101         de::MovePtr<tcu::TextureLevel>          m_sourceTextureLevel;
 102         de::MovePtr<tcu::TextureLevel>          m_destinationTextureLevel;
 103         de::MovePtr<tcu::TextureLevel>          m_expectedTextureLevel;
 104
 105         VkCommandBufferBeginInfo                        m_cmdBufferBeginInfo;
 106
 107         void                                                            generateBuffer                                          (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_SEQUENTIAL);
 108         virtual void                                            generateExpectedResult                          (void);
 109         void                                                            uploadBuffer                                            (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
 110         void                                                            uploadImage                                                     (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image);
 111         virtual tcu::TestStatus                         checkTestResult                                         (tcu::ConstPixelBufferAccess result);
 112         virtual void                                            copyRegionToTextureLevel                        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
 113         VkImageAspectFlags                                      getAspectFlag                                           (tcu::TextureFormat format);
 114         deUint32                                                        calculateSize                                           (tcu::ConstPixelBufferAccess src) const
 115                                                                                 {
 116                                                                                         return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
 117                                                                                 }
 118
 119         de::MovePtr<tcu::TextureLevel>          readImage                                                       (const vk::DeviceInterface&     vk,
 120                                                                                                                                                          vk::VkDevice                           device,
 121                                                                                                                                                          vk::VkQueue                            queue,
 122                                                                                                                                                          vk::Allocator&                         allocator,
 123                                                                                                                                                          vk::VkImage                            image,
 124                                                                                                                                                          vk::VkFormat                           format,
 125                                                                                                                                                          const VkExtent3D                       imageSize);
 126 };
 127
 128 CopiesAndBlittingTestInstance::~CopiesAndBlittingTestInstance   (void)
 129 {
 130 }
 131
 132 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance    (Context& context, TestParams testParams)
 133         : vkt::TestInstance             (context)
 134         , m_params                      (testParams)
 135 {
 136         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 137         const VkDevice                          vkDevice                        = context.getDevice();
 138         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 139
 140         // Create command pool
 141         {
 142                 const VkCommandPoolCreateInfo cmdPoolParams =
 143                 {
 144                         VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,             // VkStructureType              sType;
 145                         DE_NULL,                                                                                // const void*                  pNext;
 146                         VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,                   // VkCmdPoolCreateFlags flags;
 147                         queueFamilyIndex,                                                               // deUint32                             queueFamilyIndex;
 148                 };
 149
 150                 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
 151         }
 152
 153         // Create command buffer
 154         {
 155                 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 156                 {
 157                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 158                         DE_NULL,                                                                                // const void*                          pNext;
 159                         *m_cmdPool,                                                                             // VkCommandPool                        commandPool;
 160                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 161                         1u                                                                                              // deUint32                                     bufferCount;
 162                 };
 163
 164                 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
 165         }
 166
 167         // Create fence
 168         {
 169                 const VkFenceCreateInfo fenceParams =
 170                 {
 171                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,    // VkStructureType              sType;
 172                         DE_NULL,                                                                // const void*                  pNext;
 173                         0u                                                                              // VkFenceCreateFlags   flags;
 174                 };
 175
 176                 m_fence = createFence(vk, vkDevice, &fenceParams);
 177         }
 178 }
 179
 180 void CopiesAndBlittingTestInstance::generateBuffer(tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
 181 {
 182         de::Random rnd(width ^ height ^ depth);
 183         for (int z = 0; z < depth; z++)
 184         {
 185                 for (int y = 0; y < height; y++)
 186                 {
 187                         for (int x = 0; x < width; x++)
 188                         {
 189                                 switch (mode)
 190                                 {
 191                                         case FILL_MODE_SEQUENTIAL:
 192                                                 buffer.setPixel(tcu::UVec4(x, y, z, 255), x, y, z);
 193                                                 break;
 194                                         case FILL_MODE_WHITE:
 195                                                 buffer.setPixel(tcu::UVec4(255, 255, 255, 255), x, y, z);
 196                                                 break;
 197                                         case FILL_MODE_RED:
 198                                                 buffer.setPixel(tcu::UVec4(255, 0, 0, 255), x, y, z);
 199                                                 break;
 200                                         case FILL_MODE_RANDOM:
 201                                                 buffer.setPixel(tcu::UVec4(rnd.getUint8(), rnd.getUint8(), rnd.getUint8(), 255), x, y, z);
 202                                         default:
 203                                                 break;
 204                                 }
 205                         }
 206                 }
 207         }
 208 }
 209
 210 void CopiesAndBlittingTestInstance::uploadBuffer(tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
 211 {
 212         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 213         const VkDevice                          vkDevice        = m_context.getDevice();
 214         const deUint32                          bufferSize      = calculateSize(bufferAccess);
 215
 216         // Write buffer data
 217         deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
 218         flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
 219 }
 220
 221 void CopiesAndBlittingTestInstance::uploadImage(tcu::ConstPixelBufferAccess imageAccess, const VkImage& image)
 222 {
 223         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 224         const VkDevice                          vkDevice                        = m_context.getDevice();
 225         const VkQueue                           queue                           = m_context.getUniversalQueue();
 226         const deUint32                          queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 227         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
 228
 229         Move<VkBuffer>                          buffer;
 230         const deUint32                          bufferSize              = calculateSize(imageAccess);
 231         de::MovePtr<Allocation>         bufferAlloc;
 232         Move<VkCommandBuffer>           cmdBuffer;
 233         Move<VkFence>                           fence;
 234
 235         // Create source buffer
 236         {
 237                 const VkBufferCreateInfo                        bufferParams                    =
 238                 {
 239                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 240                         DE_NULL,                                                                        // const void*                  pNext;
 241                         0u,                                                                                     // VkBufferCreateFlags  flags;
 242                         bufferSize,                                                                     // VkDeviceSize                 size;
 243                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
 244                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 245                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 246                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 247                 };
 248
 249                 buffer          = createBuffer(vk, vkDevice, &bufferParams);
 250                 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
 251                 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 252         }
 253
 254         // Create command buffer
 255         {
 256                 const VkCommandBufferAllocateInfo       cmdBufferAllocateInfo   =
 257                 {
 258                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 259                         DE_NULL,                                                                                // const void*                          pNext;
 260                         *m_cmdPool,                                                                             // VkCommandPool                        commandPool;
 261                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 262                         1u,                                                                                             // deUint32                                     bufferCount;
 263                 };
 264
 265                 cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
 266         }
 267
 268         // Create fence
 269         {
 270                 const VkFenceCreateInfo                         fenceParams                             =
 271                 {
 272                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // VkStructureType              sType;
 273                         DE_NULL,                                                                        // const void*                  pNext;
 274                         0u                                                                                      // VkFenceCreateFlags   flags;
 275                 };
 276
 277                 fence = createFence(vk, vkDevice, &fenceParams);
 278         }
 279
 280         // Barriers for copying buffer to image
 281         const VkBufferMemoryBarrier                             preBufferBarrier                =
 282         {
 283                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,                // VkStructureType      sType;
 284                 DE_NULL,                                                                                // const void*          pNext;
 285                 VK_ACCESS_HOST_WRITE_BIT,                                               // VkAccessFlags        srcAccessMask;
 286                 VK_ACCESS_TRANSFER_READ_BIT,                                    // VkAccessFlags        dstAccessMask;
 287                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     srcQueueFamilyIndex;
 288                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                     dstQueueFamilyIndex;
 289                 *buffer,                                                                                // VkBuffer                     buffer;
 290                 0u,                                                                                             // VkDeviceSize         offset;
 291                 bufferSize                                                                              // VkDeviceSize         size;
 292         };
 293
 294         const VkImageMemoryBarrier                              preImageBarrier                 =
 295         {
 296                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 297                 DE_NULL,                                                                                // const void*                          pNext;
 298                 0u,                                                                                             // VkAccessFlags                        srcAccessMask;
 299                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        dstAccessMask;
 300                 VK_IMAGE_LAYOUT_UNDEFINED,                                              // VkImageLayout                        oldLayout;
 301                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
 302                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 303                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 304                 image,                                                                                  // VkImage                                      image;
 305                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 306                         getAspectFlag(imageAccess.getFormat()), // VkImageAspect        aspect;
 307                         0u,                                                                             // deUint32                     baseMipLevel;
 308                         1u,                                                                             // deUint32                     mipLevels;
 309                         0u,                                                                             // deUint32                     baseArraySlice;
 310                         1u,                                                                             // deUint32                     arraySize;
 311                 }
 312         };
 313
 314         const VkImageMemoryBarrier                              postImageBarrier                =
 315         {
 316                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                 // VkStructureType                      sType;
 317                 DE_NULL,                                                                                // const void*                          pNext;
 318                 VK_ACCESS_TRANSFER_WRITE_BIT,                                   // VkAccessFlags                        srcAccessMask;
 319                 VK_ACCESS_SHADER_READ_BIT,                                              // VkAccessFlags                        dstAccessMask;
 320                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        oldLayout;
 321                 VK_IMAGE_LAYOUT_GENERAL,                                                // VkImageLayout                        newLayout;
 322                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     srcQueueFamilyIndex;
 323                 VK_QUEUE_FAMILY_IGNORED,                                                // deUint32                                     dstQueueFamilyIndex;
 324                 image,                                                                                  // VkImage                                      image;
 325                 {                                                                                               // VkImageSubresourceRange      subresourceRange;
 326                         getAspectFlag(imageAccess.getFormat()), // VkImageAspect        aspect;
 327                         0u,                                                                             // deUint32                     baseMipLevel;
 328                         1u,                                                                             // deUint32                     mipLevels;
 329                         0u,                                                                             // deUint32                     baseArraySlice;
 330                         1u,                                                                             // deUint32                     arraySize;
 331                 }
 332         };
 333
 334         const VkBufferImageCopy                                 copyRegion                              =
 335         {
 336                 0u,                                                                                             // VkDeviceSize                         bufferOffset;
 337                 (deUint32)imageAccess.getWidth(),                               // deUint32                                     bufferRowLength;
 338                 (deUint32)imageAccess.getHeight(),                              // deUint32                                     bufferImageHeight;
 339                 {                                                                                               // VkImageSubresourceLayers     imageSubresource;
 340                         getAspectFlag(imageAccess.getFormat()), // VkImageAspect        aspect;
 341                         0u,                                                                             // deUint32                     mipLevel;
 342                         0u,                                                                             // deUint32                     baseArrayLayer;
 343                         1u,                                                                             // deUint32                     layerCount;
 344                 },
 345                 { 0, 0, 0 },                                                                    // VkOffset3D                           imageOffset;
 346                 {
 347                         (deUint32)imageAccess.getWidth(),
 348                         (deUint32)imageAccess.getHeight(),
 349                         1u
 350                 }                                                                                               // VkExtent3D                           imageExtent;
 351         };
 352
 353         // Write buffer data
 354         deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
 355         flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
 356
 357         // Copy buffer to image
 358         const VkCommandBufferBeginInfo                  cmdBufferBeginInfo              =
 359         {
 360                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 361                 DE_NULL,                                                                                                // const void*                                          pNext;
 362                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 363                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 364         };
 365
 366         VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
 367         vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
 368         vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);
 369         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);
 370         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 371
 372         const VkSubmitInfo                                              submitInfo                              =
 373         {
 374                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 375                 DE_NULL,                                                // const void*                          pNext;
 376                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 377                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 378                 (const VkPipelineStageFlags*)DE_NULL,
 379                 1u,                                                             // deUint32                                     commandBufferCount;
 380                 &cmdBuffer.get(),                               // const VkCommandBuffer*       pCommandBuffers;
 381                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 382                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 383         };
 384
 385         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
 386         VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
 387 }
 388
 389 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult(tcu::ConstPixelBufferAccess result)
 390 {
 391         const tcu::ConstPixelBufferAccess       expected        = m_expectedTextureLevel->getAccess();
 392         const tcu::UVec4                                        treshold        (0, 0, 0, 0);
 393
 394         if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, treshold, tcu::COMPARE_LOG_RESULT))
 395                 return tcu::TestStatus::fail("CopiesAndBlitting test");
 396
 397         return tcu::TestStatus::pass("CopiesAndBlitting test");
 398 }
 399
 400 void CopiesAndBlittingTestInstance::generateExpectedResult()
 401 {
 402         const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
 403         const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
 404
 405         m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
 406         tcu::copy(m_expectedTextureLevel->getAccess(), dst);
 407         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 408                 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
 409 }
 410
 411 class CopiesAndBlittingTestCase : public vkt::TestCase
 412 {
 413 public:
 414                                                         CopiesAndBlittingTestCase       (tcu::TestContext&                      testCtx,
 415                                                                                                                  const std::string&                     name,
 416                                                                                                                  const std::string&                     description)
 417                                                                 : vkt::TestCase                 (testCtx, name, description)
 418                                                         {}
 419
 420         virtual                                 ~CopiesAndBlittingTestCase      (void) {}
 421
 422         virtual TestInstance*   createInstance                          (Context&                                       context) const = 0;
 423 };
 424
 425 VkImageAspectFlags CopiesAndBlittingTestInstance::getAspectFlag(tcu::TextureFormat format)
 426 {
 427         VkImageAspectFlags aspectFlag = 0;
 428         aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
 429         aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
 430
 431         if (!aspectFlag)
 432                 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
 433
 434         return aspectFlag;
 435 }
 436
 437 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (const vk::DeviceInterface&     vk,
 438                                                                                                                                                  vk::VkDevice                           device,
 439                                                                                                                                                  vk::VkQueue                            queue,
 440                                                                                                                                                  vk::Allocator&                         allocator,
 441                                                                                                                                                  vk::VkImage                            image,
 442                                                                                                                                                  vk::VkFormat                           format,
 443                                                                                                                                                  const VkExtent3D                       imageSize)
 444 {
 445         Move<VkBuffer>                                  buffer;
 446         de::MovePtr<Allocation>                 bufferAlloc;
 447         Move<VkCommandBuffer>                   cmdBuffer;
 448         Move<VkFence>                                   fence;
 449         const deUint32                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
 450         const tcu::TextureFormat                tcuFormat                       = mapVkFormat(format);
 451         const VkDeviceSize                              pixelDataSize           = imageSize.width * imageSize.height * imageSize.depth * tcu::getPixelSize(tcuFormat);
 452         de::MovePtr<tcu::TextureLevel>  resultLevel                     (new tcu::TextureLevel(tcuFormat, imageSize.width, imageSize.height, imageSize.depth));
 453
 454         // Create destination buffer
 455         {
 456                 const VkBufferCreateInfo bufferParams =
 457                 {
 458                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 459                         DE_NULL,                                                                        // const void*                  pNext;
 460                         0u,                                                                                     // VkBufferCreateFlags  flags;
 461                         pixelDataSize,                                                          // VkDeviceSize                 size;
 462                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 463                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 464                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 465                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 466                 };
 467
 468                 buffer          = createBuffer(vk, device, &bufferParams);
 469                 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
 470                 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
 471         }
 472
 473         // Create command pool and buffer
 474         {
 475                 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
 476                 {
 477                         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                      sType;
 478                         DE_NULL,                                                                                // const void*                          pNext;
 479                         *m_cmdPool,                                                                             // VkCommandPool                        commandPool;
 480                         VK_COMMAND_BUFFER_LEVEL_PRIMARY,                                // VkCommandBufferLevel         level;
 481                         1u                                                                                              // deUint32                                     bufferCount;
 482                 };
 483
 484                 cmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo);
 485         }
 486
 487         // Create fence
 488         {
 489                 const VkFenceCreateInfo fenceParams =
 490                 {
 491                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,            // VkStructureType              sType;
 492                         DE_NULL,                                                                        // const void*                  pNext;
 493                         0u                                                                                      // VkFenceCreateFlags   flags;
 494                 };
 495
 496                 fence = createFence(vk, device, &fenceParams);
 497         }
 498
 499         // Barriers for copying image to buffer
 500
 501         const VkImageMemoryBarrier imageBarrier =
 502         {
 503                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 504                 DE_NULL,                                                                        // const void*                          pNext;
 505                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 506                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 507                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        oldLayout;
 508                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 509                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 510                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 511                 image,                                                                          // VkImage                                      image;
 512                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
 513                         getAspectFlag(tcuFormat),       // VkImageAspectFlags   aspectMask;
 514                         0u,                                                     // deUint32                             baseMipLevel;
 515                         1u,                                                     // deUint32                             mipLevels;
 516                         0u,                                                     // deUint32                             baseArraySlice;
 517                         1u                                                      // deUint32                             arraySize;
 518                 }
 519         };
 520
 521         const VkBufferMemoryBarrier bufferBarrier =
 522         {
 523                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 524                 DE_NULL,                                                                        // const void*          pNext;
 525                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 526                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 527                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 528                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 529                 *buffer,                                                                        // VkBuffer                     buffer;
 530                 0u,                                                                                     // VkDeviceSize         offset;
 531                 pixelDataSize                                                           // VkDeviceSize         size;
 532         };
 533
 534         // Copy image to buffer
 535
 536         const VkBufferImageCopy copyRegion =
 537         {
 538                 0u,                                                                                     // VkDeviceSize                         bufferOffset;
 539                 (deUint32)imageSize.width,                                      // deUint32                                     bufferRowLength;
 540                 (deUint32)imageSize.height,                                     // deUint32                                     bufferImageHeight;
 541                 { getAspectFlag(tcuFormat), 0u, 0u, 1u },       // VkImageSubresourceLayers     imageSubresource;
 542                 { 0, 0, 0 },                                                            // VkOffset3D                           imageOffset;
 543                 imageSize                                                                       // VkExtent3D                           imageExtent;
 544         };
 545
 546         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 547         {
 548                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 549                 DE_NULL,                                                                                                // const void*                                          pNext;
 550                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 551                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 552         };
 553
 554         VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
 555         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);
 556         vk.cmdCopyImageToBuffer(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, &copyRegion);
 557         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);
 558         VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
 559
 560         const VkSubmitInfo submitInfo =
 561         {
 562                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 563                 DE_NULL,                                                // const void*                          pNext;
 564                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 565                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 566                 (const VkPipelineStageFlags*)DE_NULL,
 567                 1u,                                                             // deUint32                                     commandBufferCount;
 568                 &cmdBuffer.get(),                               // const VkCommandBuffer*       pCommandBuffers;
 569                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 570                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 571         };
 572
 573         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
 574         VK_CHECK(vk.waitForFences(device, 1, &fence.get(), 0, ~(0ull) /* infinity */));
 575
 576         // Read buffer data
 577         invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
 578         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
 579
 580         return resultLevel;
 581 }
 582
 583 // Copy from image to image.
 584
 585 class CopyImageToImage : public CopiesAndBlittingTestInstance
 586 {
 587 public:
 588                                                                                 CopyImageToImage                        (Context&       context,
 589                                                                                                                                          TestParams params);
 590         virtual tcu::TestStatus                         iterate                                         (void);
 591 private:
 592         Move<VkImage>                                           m_source;
 593         de::MovePtr<Allocation>                         m_sourceImageAlloc;
 594         Move<VkImage>                                           m_destination;
 595         de::MovePtr<Allocation>                         m_destinationImageAlloc;
 596
 597         virtual void                                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
 598 };
 599
 600 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
 601         : CopiesAndBlittingTestInstance(context, params)
 602 {
 603         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 604         const VkDevice                          vkDevice                        = context.getDevice();
 605         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 606         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
 607
 608         VkImageFormatProperties properties;
 609         if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
 610                                                                                                                                                                 m_params.src.image.format,
 611                                                                                                                                                                 VK_IMAGE_TYPE_2D,
 612                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
 613                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
 614                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
 615                 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
 616                                                                                                                                                                 m_params.dst.image.format,
 617                                                                                                                                                                 VK_IMAGE_TYPE_2D,
 618                                                                                                                                                                 VK_IMAGE_TILING_OPTIMAL,
 619                                                                                                                                                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
 620                                                                                                                                                                 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
 621         {
 622                 TCU_THROW(NotSupportedError, "Format not supported");
 623         }
 624
 625         // Create source image
 626         {
 627                 const VkImageCreateInfo sourceImageParams =
 628                 {
 629                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
 630                         DE_NULL,                                                                // const void*                  pNext;
 631                         0u,                                                                             // VkImageCreateFlags   flags;
 632                         VK_IMAGE_TYPE_2D,                                               // VkImageType                  imageType;
 633                         m_params.src.image.format,                              // VkFormat                             format;
 634                         m_params.src.image.extent,                              // VkExtent3D                   extent;
 635                         1u,                                                                             // deUint32                             mipLevels;
 636                         1u,                                                                             // deUint32                             arraySize;
 637                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
 638                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
 639                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 640                             VK_IMAGE_USAGE_TRANSFER_DST_BIT,    // VkImageUsageFlags    usage;
 641                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 642                         1u,                                                                             // deUint32                             queueFamilyCount;
 643                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
 644                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
 645                 };
 646
 647                 m_source = createImage(vk, vkDevice, &sourceImageParams);
 648                 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
 649                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
 650         }
 651
 652         // Create destination image
 653         {
 654                 const VkImageCreateInfo destinationImageParams =
 655                 {
 656                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
 657                         DE_NULL,                                                                // const void*                  pNext;
 658                         0u,                                                                             // VkImageCreateFlags   flags;
 659                         VK_IMAGE_TYPE_2D,                                               // VkImageType                  imageType;
 660                         m_params.dst.image.format,                              // VkFormat                             format;
 661                         m_params.dst.image.extent,                              // VkExtent3D                   extent;
 662                         1u,                                                                             // deUint32                             mipLevels;
 663                         1u,                                                                             // deUint32                             arraySize;
 664                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
 665                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
 666                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
 667                             VK_IMAGE_USAGE_TRANSFER_DST_BIT,    // VkImageUsageFlags    usage;
 668                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
 669                         1u,                                                                             // deUint32                             queueFamilyCount;
 670                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
 671                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
 672                 };
 673
 674                 m_destination = createImage(vk, vkDevice, &destinationImageParams);
 675                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
 676                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
 677         }
 678 }
 679
 680 tcu::TestStatus CopyImageToImage::iterate()
 681 {
 682         tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
 683         tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
 684         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
 685                                                                                                                                                                 m_params.src.image.extent.width,
 686                                                                                                                                                                 m_params.src.image.extent.height,
 687                                                                                                                                                                 m_params.src.image.extent.depth));
 688         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);
 689         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
 690                                                                                                                                                                          (int)m_params.dst.image.extent.width,
 691                                                                                                                                                                          (int)m_params.dst.image.extent.height,
 692                                                                                                                                                                          (int)m_params.dst.image.extent.depth));
 693         generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_SEQUENTIAL);
 694         generateExpectedResult();
 695
 696         uploadImage(m_sourceTextureLevel->getAccess(), m_source.get());
 697         uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get());
 698
 699         const DeviceInterface&          vk                                      = m_context.getDeviceInterface();
 700         const VkDevice                          vkDevice                        = m_context.getDevice();
 701         const VkQueue                           queue                           = m_context.getUniversalQueue();
 702         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
 703
 704         VkImageCopy* imageCopies = ((VkImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkImageCopy)));
 705         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 706                 imageCopies[i] = m_params.regions[i].imageCopy;
 707
 708         const VkImageMemoryBarrier imageBarriers[] =
 709         {
 710                 // source image
 711                 {
 712                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 713                         DE_NULL,                                                                        // const void*                          pNext;
 714                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 715                         VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
 716                         VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                        oldLayout;
 717                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
 718                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 719                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 720                         m_source.get(),                                                         // VkImage                                      image;
 721                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
 722                                 getAspectFlag(srcTcuFormat),    // VkImageAspectFlags   aspectMask;
 723                                 0u,                                                             // deUint32                             baseMipLevel;
 724                                 1u,                                                             // deUint32                             mipLevels;
 725                                 0u,                                                             // deUint32                             baseArraySlice;
 726                                 1u                                                              // deUint32                             arraySize;
 727                         }
 728                 },
 729                 // destination image
 730                 {
 731                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
 732                         DE_NULL,                                                                        // const void*                          pNext;
 733                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
 734                         VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
 735                         VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                        oldLayout;
 736                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
 737                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
 738                         VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
 739                         m_destination.get(),                                            // VkImage                                      image;
 740                         {                                                                                       // VkImageSubresourceRange      subresourceRange;
 741                                 getAspectFlag(dstTcuFormat),    // VkImageAspectFlags   aspectMask;
 742                                 0u,                                                             // deUint32                             baseMipLevel;
 743                                 1u,                                                             // deUint32                             mipLevels;
 744                                 0u,                                                             // deUint32                             baseArraySlice;
 745                                 1u                                                              // deUint32                             arraySize;
 746                         }
 747                 },
 748         };
 749
 750         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 751         {
 752                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 753                 DE_NULL,                                                                                                // const void*                                          pNext;
 754                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 755                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 756         };
 757
 758         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 759         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);
 760         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);
 761         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 762
 763         const VkSubmitInfo submitInfo =
 764         {
 765                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 766                 DE_NULL,                                                // const void*                          pNext;
 767                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 768                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 769                 (const VkPipelineStageFlags*)DE_NULL,
 770                 1u,                                                             // deUint32                                     commandBufferCount;
 771                 &m_cmdBuffer.get(),                             // const VkCommandBuffer*       pCommandBuffers;
 772                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 773                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 774         };
 775
 776         VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
 777         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
 778         VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
 779         deFree(imageCopies);
 780
 781         de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image.format, m_params.dst.image.extent);
 782
 783         return checkTestResult(resultTextureLevel->getAccess());
 784 }
 785
 786 void CopyImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
 787 {
 788         VkOffset3D srcOffset    = region.imageCopy.srcOffset;
 789         VkOffset3D dstOffset    = region.imageCopy.dstOffset;
 790         VkExtent3D extent               = region.imageCopy.extent;
 791
 792         const tcu::ConstPixelBufferAccess       srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, extent.width, extent.height);
 793         // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
 794         const tcu::PixelBufferAccess            dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
 795         const tcu::PixelBufferAccess            dstSubRegion = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, extent.width, extent.height);
 796
 797         tcu::copy(dstSubRegion, srcSubRegion);
 798 }
 799
 800 class CopyImageToImageTestCase : public vkt::TestCase
 801 {
 802 public:
 803                                                         CopyImageToImageTestCase        (tcu::TestContext&                              testCtx,
 804                                                                                                                  const std::string&                             name,
 805                                                                                                                  const std::string&                             description,
 806                                                                                                                  const TestParams                               params)
 807                                                                 : vkt::TestCase                 (testCtx, name, description)
 808                                                                 , m_params                              (params)
 809                                                         {}
 810
 811         virtual                                 ~CopyImageToImageTestCase       (void) {}
 812
 813         virtual TestInstance*   createInstance                          (Context&                                               context) const
 814                                                         {
 815                                                                 return new CopyImageToImage(context, m_params);
 816                                                         }
 817 private:
 818         TestParams                              m_params;
 819 };
 820
 821 // Copy from buffer to buffer.
 822
 823 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
 824 {
 825 public:
 826                                                                 CopyBufferToBuffer                      (Context& context, TestParams params);
 827         virtual tcu::TestStatus         iterate                                         (void);
 828 private:
 829         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
 830         Move<VkBuffer>                          m_source;
 831         de::MovePtr<Allocation>         m_sourceBufferAlloc;
 832         Move<VkBuffer>                          m_destination;
 833         de::MovePtr<Allocation>         m_destinationBufferAlloc;
 834 };
 835
 836 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
 837         : CopiesAndBlittingTestInstance (context, params)
 838 {
 839         const DeviceInterface&          vk                                      = context.getDeviceInterface();
 840         const VkDevice                          vkDevice                        = context.getDevice();
 841         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
 842         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
 843
 844         // Create source buffer
 845         {
 846                 const VkBufferCreateInfo        sourceBufferParams      =
 847                 {
 848                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 849                         DE_NULL,                                                                        // const void*                  pNext;
 850                         0u,                                                                                     // VkBufferCreateFlags  flags;
 851                         m_params.src.buffer.size,                                       // VkDeviceSize                 size;
 852                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
 853                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 854                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 855                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 856                 };
 857
 858                 m_source                                = createBuffer(vk, vkDevice, &sourceBufferParams);
 859                 m_sourceBufferAlloc             = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
 860                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
 861         }
 862
 863         // Create desctination buffer
 864         {
 865                 const VkBufferCreateInfo        destinationBufferParams =
 866                 {
 867                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
 868                         DE_NULL,                                                                        // const void*                  pNext;
 869                         0u,                                                                                     // VkBufferCreateFlags  flags;
 870                         m_params.dst.buffer.size,                                       // VkDeviceSize                 size;
 871                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
 872                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
 873                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
 874                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
 875                 };
 876
 877                 m_destination                           = createBuffer(vk, vkDevice, &destinationBufferParams);
 878                 m_destinationBufferAlloc        = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
 879                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
 880         }
 881 }
 882
 883 tcu::TestStatus CopyBufferToBuffer::iterate()
 884 {
 885         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
 886         m_sourceTextureLevel            = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
 887         generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
 888
 889         const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
 890         m_destinationTextureLevel       = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
 891         generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
 892
 893         generateExpectedResult();
 894
 895         uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
 896         uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
 897
 898         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
 899         const VkDevice                          vkDevice        = m_context.getDevice();
 900         const VkQueue                           queue           = m_context.getUniversalQueue();
 901
 902         const VkBufferMemoryBarrier srcBufferBarrier =
 903         {
 904                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 905                 DE_NULL,                                                                        // const void*          pNext;
 906                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 907                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 908                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 909                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 910                 *m_source,                                                                      // VkBuffer                     buffer;
 911                 0u,                                                                                     // VkDeviceSize         offset;
 912                 m_params.src.buffer.size                                        // VkDeviceSize         size;
 913         };
 914
 915         const VkBufferMemoryBarrier dstBufferBarrier    =
 916         {
 917                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
 918                 DE_NULL,                                                                        // const void*          pNext;
 919                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
 920                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
 921                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
 922                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
 923                 *m_destination,                                                         // VkBuffer                     buffer;
 924                 0u,                                                                                     // VkDeviceSize         offset;
 925                 m_params.dst.buffer.size                                        // VkDeviceSize         size;
 926         };
 927
 928         VkBufferCopy* bufferCopies = ((VkBufferCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferCopy)));
 929         for (deUint32 i = 0; i < m_params.regions.size(); i++)
 930                 bufferCopies[i] = m_params.regions[i].bufferCopy;
 931
 932         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 933         {
 934                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
 935                 DE_NULL,                                                                                                // const void*                                          pNext;
 936                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
 937                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 938         };
 939
 940         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 941         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &srcBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
 942         vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), bufferCopies);
 943         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);
 944         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 945
 946         const VkSubmitInfo submitInfo =
 947         {
 948                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
 949                 DE_NULL,                                                // const void*                          pNext;
 950                 0u,                                                             // deUint32                                     waitSemaphoreCount;
 951                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
 952                 (const VkPipelineStageFlags*)DE_NULL,
 953                 1u,                                                             // deUint32                                     commandBufferCount;
 954                 &m_cmdBuffer.get(),                             // const VkCommandBuffer*       pCommandBuffers;
 955                 0u,                                                             // deUint32                                     signalSemaphoreCount;
 956                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
 957         };
 958
 959         VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
 960         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
 961         VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
 962
 963         // Read buffer data
 964         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
 965         invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
 966         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
 967         deFree(bufferCopies);
 968
 969         return checkTestResult(resultLevel->getAccess());
 970 }
 971
 972 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
 973 {
 974         deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
 975                                 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
 976                                 (size_t)region.bufferCopy.size);
 977 }
 978
 979 class BufferToBufferTestCase : public vkt::TestCase
 980 {
 981 public:
 982                                                         BufferToBufferTestCase  (tcu::TestContext&      testCtx,
 983                                                                                                          const std::string&     name,
 984                                                                                                          const std::string&     description,
 985                                                                                                          const TestParams       params)
 986                                                                 : vkt::TestCase         (testCtx, name, description)
 987                                                                 , m_params                      (params)
 988                                                         {}
 989         virtual                                 ~BufferToBufferTestCase (void) {}
 990
 991         virtual TestInstance*   createInstance                  (Context& context) const
 992                                                         {
 993                                                                 return new CopyBufferToBuffer(context, m_params);
 994                                                         }
 995 private:
 996         TestParams                              m_params;
 997 };
 998
 999 // Copy from image to buffer.
1000
1001 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1002 {
1003 public:
1004                                                                 CopyImageToBuffer                       (Context&       context,
1005                                                                                                                          TestParams     testParams);
1006         virtual                                         ~CopyImageToBuffer                      (void) {}
1007         virtual tcu::TestStatus         iterate                                         (void);
1008 private:
1009         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1010
1011         tcu::TextureFormat                      m_textureFormat;
1012         VkDeviceSize                            m_bufferSize;
1013
1014         Move<VkImage>                           m_source;
1015         de::MovePtr<Allocation>         m_sourceImageAlloc;
1016         Move<VkBuffer>                          m_destination;
1017         de::MovePtr<Allocation>         m_destinationBufferAlloc;
1018 };
1019
1020 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1021         : CopiesAndBlittingTestInstance(context, testParams)
1022         , m_textureFormat(mapVkFormat(testParams.src.image.format))
1023         , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1024 {
1025         const DeviceInterface&          vk                                      = context.getDeviceInterface();
1026         const VkDevice                          vkDevice                        = context.getDevice();
1027         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
1028         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1029
1030         // Create source image
1031         {
1032                 const VkImageCreateInfo         sourceImageParams               =
1033                 {
1034                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1035                         DE_NULL,                                                                // const void*                  pNext;
1036                         0u,                                                                             // VkImageCreateFlags   flags;
1037                         VK_IMAGE_TYPE_2D,                                               // VkImageType                  imageType;
1038                         m_params.src.image.format,                              // VkFormat                             format;
1039                         m_params.src.image.extent,                              // VkExtent3D                   extent;
1040                         1u,                                                                             // deUint32                             mipLevels;
1041                         1u,                                                                             // deUint32                             arraySize;
1042                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1043                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1044                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1045                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1046                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1047                         1u,                                                                             // deUint32                             queueFamilyCount;
1048                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1049                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1050                 };
1051
1052                 m_source                        = createImage(vk, vkDevice, &sourceImageParams);
1053                 m_sourceImageAlloc      = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1054                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1055         }
1056
1057         // Create destination buffer
1058         {
1059                 const VkBufferCreateInfo        destinationBufferParams =
1060                 {
1061                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1062                         DE_NULL,                                                                        // const void*                  pNext;
1063                         0u,                                                                                     // VkBufferCreateFlags  flags;
1064                         m_bufferSize,                                                           // VkDeviceSize                 size;
1065                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,                       // VkBufferUsageFlags   usage;
1066                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1067                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
1068                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
1069                 };
1070
1071                 m_destination                           = createBuffer(vk, vkDevice, &destinationBufferParams);
1072                 m_destinationBufferAlloc        = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1073                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1074         }
1075 }
1076
1077 tcu::TestStatus CopyImageToBuffer::iterate()
1078 {
1079         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1080                                                                                                                                                                 m_params.src.image.extent.width,
1081                                                                                                                                                                 m_params.src.image.extent.height,
1082                                                                                                                                                                 m_params.src.image.extent.depth));
1083         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);
1084         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1085         generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1086
1087         generateExpectedResult();
1088
1089         uploadImage(m_sourceTextureLevel->getAccess(), *m_source);
1090         uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1091
1092         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
1093         const VkDevice                          vkDevice        = m_context.getDevice();
1094         const VkQueue                           queue           = m_context.getUniversalQueue();
1095
1096         // Barriers for copying image to buffer
1097         const VkImageMemoryBarrier imageBarrier =
1098         {
1099                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1100                 DE_NULL,                                                                        // const void*                          pNext;
1101                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1102                 VK_ACCESS_TRANSFER_READ_BIT,                            // VkAccessFlags                        dstAccessMask;
1103                 VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                        oldLayout;
1104                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,           // VkImageLayout                        newLayout;
1105                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1106                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1107                 *m_source,                                                                      // VkImage                                      image;
1108                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1109                         getAspectFlag(m_textureFormat), // VkImageAspectFlags   aspectMask;
1110                         0u,                                                             // deUint32                             baseMipLevel;
1111                         1u,                                                             // deUint32                             mipLevels;
1112                         0u,                                                             // deUint32                             baseArraySlice;
1113                         1u                                                              // deUint32                             arraySize;
1114                 }
1115         };
1116
1117         const VkBufferMemoryBarrier bufferBarrier =
1118         {
1119                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType      sType;
1120                 DE_NULL,                                                                        // const void*          pNext;
1121                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags        srcAccessMask;
1122                 VK_ACCESS_HOST_READ_BIT,                                        // VkAccessFlags        dstAccessMask;
1123                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     srcQueueFamilyIndex;
1124                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                     dstQueueFamilyIndex;
1125                 *m_destination,                                                         // VkBuffer                     buffer;
1126                 0u,                                                                                     // VkDeviceSize         offset;
1127                 m_bufferSize                                                            // VkDeviceSize         size;
1128         };
1129
1130         // Copy from image to buffer
1131         VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
1132         for (deUint32 i = 0; i < m_params.regions.size(); i++)
1133                 bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
1134
1135         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1136         {
1137                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1138                 DE_NULL,                                                                                                // const void*                                          pNext;
1139                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1140                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1141         };
1142
1143         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1144         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);
1145         vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), bufferImageCopies);
1146         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);
1147         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1148
1149         const VkSubmitInfo                              submitInfo              =
1150         {
1151                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
1152                 DE_NULL,                                                // const void*                          pNext;
1153                 0u,                                                             // deUint32                                     waitSemaphoreCount;
1154                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
1155                 (const VkPipelineStageFlags*)DE_NULL,
1156                 1u,                                                             // deUint32                                     commandBufferCount;
1157                 &m_cmdBuffer.get(),                             // const VkCommandBuffer*       pCommandBuffers;
1158                 0u,                                                             // deUint32                                     signalSemaphoreCount;
1159                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
1160         };
1161
1162         VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
1163         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
1164         VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
1165
1166         // Read buffer data
1167         de::MovePtr<tcu::TextureLevel>  resultLevel             (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1168         invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1169         tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1170         deFree(bufferImageCopies);
1171
1172         return checkTestResult(resultLevel->getAccess());
1173 }
1174
1175 class CopyImageToBufferTestCase : public vkt::TestCase
1176 {
1177 public:
1178                                                         CopyImageToBufferTestCase       (tcu::TestContext&              testCtx,
1179                                                                                                                  const std::string&             name,
1180                                                                                                                  const std::string&             description,
1181                                                                                                                  const TestParams               params)
1182                                                                 : vkt::TestCase                 (testCtx, name, description)
1183                                                                 , m_params                              (params)
1184                                                         {}
1185
1186         virtual                                 ~CopyImageToBufferTestCase      (void) {}
1187
1188         virtual TestInstance*   createInstance                          (Context&                               context) const
1189                                                         {
1190                                                                 return new CopyImageToBuffer(context, m_params);
1191                                                         }
1192 private:
1193         TestParams                              m_params;
1194 };
1195
1196 void CopyImageToBuffer::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1197 {
1198         deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1199         if (!rowLength)
1200                 rowLength = region.bufferImageCopy.imageExtent.width;
1201
1202         deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1203         if (!imageHeight)
1204                 imageHeight = region.bufferImageCopy.imageExtent.height;
1205
1206         const int                       texelSize       = src.getFormat().getPixelSize();
1207         const VkExtent3D        extent          = region.bufferImageCopy.imageExtent;
1208         const VkOffset3D        srcOffset       = region.bufferImageCopy.imageOffset;
1209         const int                       texelOffset     = (int) region.bufferImageCopy.bufferOffset / texelSize;
1210
1211         for (deUint32 z = 0; z < extent.depth; z++)
1212         {
1213                 for (deUint32 y = 0; y < extent.height; y++)
1214                 {
1215                         int                                                                     texelIndex              = texelOffset + (z * imageHeight + y) *  rowLength;
1216                         const tcu::ConstPixelBufferAccess       srcSubRegion    = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1217                                                                                                                                                                         region.bufferImageCopy.imageExtent.width, 1, 1);
1218                         const tcu::PixelBufferAccess            dstSubRegion    = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1219                         tcu::copy(dstSubRegion, srcSubRegion);
1220                 }
1221         }
1222 }
1223
1224 // Copy from buffer to image.
1225
1226 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1227 {
1228 public:
1229                                                                 CopyBufferToImage                       (Context&       context,
1230                                                                                                                          TestParams     testParams);
1231         virtual                                         ~CopyBufferToImage                      (void) {}
1232         virtual tcu::TestStatus         iterate                                         (void);
1233 private:
1234         virtual void                            copyRegionToTextureLevel        (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1235
1236         tcu::TextureFormat                      m_textureFormat;
1237         VkDeviceSize                            m_bufferSize;
1238
1239         Move<VkBuffer>                          m_source;
1240         de::MovePtr<Allocation>         m_sourceBufferAlloc;
1241         Move<VkImage>                           m_destination;
1242         de::MovePtr<Allocation>         m_destinationImageAlloc;
1243 };
1244
1245 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1246         : CopiesAndBlittingTestInstance(context, testParams)
1247         , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1248         , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1249 {
1250         const DeviceInterface&          vk                                      = context.getDeviceInterface();
1251         const VkDevice                          vkDevice                        = context.getDevice();
1252         const deUint32                          queueFamilyIndex        = context.getUniversalQueueFamilyIndex();
1253         SimpleAllocator                         memAlloc                        (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1254
1255         // Create source buffer
1256         {
1257                 const VkBufferCreateInfo        sourceBufferParams              =
1258                 {
1259                         VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,           // VkStructureType              sType;
1260                         DE_NULL,                                                                        // const void*                  pNext;
1261                         0u,                                                                                     // VkBufferCreateFlags  flags;
1262                         m_bufferSize,                                                           // VkDeviceSize                 size;
1263                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,                       // VkBufferUsageFlags   usage;
1264                         VK_SHARING_MODE_EXCLUSIVE,                                      // VkSharingMode                sharingMode;
1265                         1u,                                                                                     // deUint32                             queueFamilyIndexCount;
1266                         &queueFamilyIndex,                                                      // const deUint32*              pQueueFamilyIndices;
1267                 };
1268
1269                 m_source                                = createBuffer(vk, vkDevice, &sourceBufferParams);
1270                 m_sourceBufferAlloc             = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1271                 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1272         }
1273
1274         // Create destination image
1275         {
1276                 const VkImageCreateInfo         destinationImageParams  =
1277                 {
1278                         VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType              sType;
1279                         DE_NULL,                                                                // const void*                  pNext;
1280                         0u,                                                                             // VkImageCreateFlags   flags;
1281                         VK_IMAGE_TYPE_2D,                                               // VkImageType                  imageType;
1282                         m_params.dst.image.format,                              // VkFormat                             format;
1283                         m_params.dst.image.extent,                              // VkExtent3D                   extent;
1284                         1u,                                                                             // deUint32                             mipLevels;
1285                         1u,                                                                             // deUint32                             arraySize;
1286                         VK_SAMPLE_COUNT_1_BIT,                                  // deUint32                             samples;
1287                         VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                tiling;
1288                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1289                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT,        // VkImageUsageFlags    usage;
1290                         VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                sharingMode;
1291                         1u,                                                                             // deUint32                             queueFamilyCount;
1292                         &queueFamilyIndex,                                              // const deUint32*              pQueueFamilyIndices;
1293                         VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                initialLayout;
1294                 };
1295
1296                 m_destination                   = createImage(vk, vkDevice, &destinationImageParams);
1297                 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1298                 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1299         }
1300 }
1301
1302 tcu::TestStatus CopyBufferToImage::iterate()
1303 {
1304         m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1305         generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1306         m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1307                                                                                                                                                                         m_params.dst.image.extent.width,
1308                                                                                                                                                                         m_params.dst.image.extent.height,
1309                                                                                                                                                                         m_params.dst.image.extent.depth));
1310
1311         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);
1312
1313         generateExpectedResult();
1314
1315         uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1316         uploadImage(m_destinationTextureLevel->getAccess(), *m_destination);
1317
1318         const DeviceInterface&          vk                      = m_context.getDeviceInterface();
1319         const VkDevice                          vkDevice        = m_context.getDevice();
1320         const VkQueue                           queue           = m_context.getUniversalQueue();
1321         SimpleAllocator                         memAlloc        (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
1322
1323         const VkImageMemoryBarrier imageBarrier =
1324         {
1325                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
1326                 DE_NULL,                                                                        // const void*                          pNext;
1327                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
1328                 VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
1329                 VK_IMAGE_LAYOUT_GENERAL,                                        // VkImageLayout                        oldLayout;
1330                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,           // VkImageLayout                        newLayout;
1331                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
1332                 VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
1333                 *m_destination,                                                         // VkImage                                      image;
1334                 {                                                                                       // VkImageSubresourceRange      subresourceRange;
1335                         getAspectFlag(m_textureFormat), // VkImageAspectFlags   aspectMask;
1336                         0u,                                                             // deUint32                             baseMipLevel;
1337                         1u,                                                             // deUint32                             mipLevels;
1338                         0u,                                                             // deUint32                             baseArraySlice;
1339                         1u                                                              // deUint32                             arraySize;
1340                 }
1341         };
1342
1343         // Copy from buffer to image
1344         VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
1345         for (deUint32 i = 0; i < m_params.regions.size(); i++)
1346                 bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
1347
1348         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1349         {
1350                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,                    // VkStructureType                                      sType;
1351                 DE_NULL,                                                                                                // const void*                                          pNext;
1352                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,                    // VkCommandBufferUsageFlags            flags;
1353                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1354         };
1355
1356         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1357         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);
1358         vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies);
1359         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1360
1361         const VkSubmitInfo                              submitInfo              =
1362         {
1363                 VK_STRUCTURE_TYPE_SUBMIT_INFO,  // VkStructureType                      sType;
1364                 DE_NULL,                                                // const void*                          pNext;
1365                 0u,                                                             // deUint32                                     waitSemaphoreCount;
1366                 DE_NULL,                                                // const VkSemaphore*           pWaitSemaphores;
1367                 (const VkPipelineStageFlags*)DE_NULL,
1368                 1u,                                                             // deUint32                                     commandBufferCount;
1369                 &m_cmdBuffer.get(),                             // const VkCommandBuffer*       pCommandBuffers;
1370                 0u,                                                             // deUint32                                     signalSemaphoreCount;
1371                 DE_NULL                                                 // const VkSemaphore*           pSignalSemaphores;
1372         };
1373
1374         VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
1375         VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
1376         VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
1377
1378         de::MovePtr<tcu::TextureLevel>  resultLevel     = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image.format, m_params.dst.image.extent);
1379         deFree(bufferImageCopies);
1380
1381         return checkTestResult(resultLevel->getAccess());
1382 }
1383
1384 class CopyBufferToImageTestCase : public vkt::TestCase
1385 {
1386 public:
1387                                                         CopyBufferToImageTestCase       (tcu::TestContext&              testCtx,
1388                                                                                                                  const std::string&             name,
1389                                                                                                                  const std::string&             description,
1390                                                                                                                  const TestParams               params)
1391                                                                 : vkt::TestCase                 (testCtx, name, description)
1392                                                                 , m_params                              (params)
1393                                                         {}
1394
1395         virtual                                 ~CopyBufferToImageTestCase      (void) {}
1396
1397         virtual TestInstance*   createInstance                          (Context&                               context) const
1398                                                         {
1399                                                                 return new CopyBufferToImage(context, m_params);
1400                                                         }
1401 private:
1402         TestParams                              m_params;
1403 };
1404
1405 void CopyBufferToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1406 {
1407         deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1408         if (!rowLength)
1409                 rowLength = region.bufferImageCopy.imageExtent.width;
1410
1411         deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1412         if (!imageHeight)
1413                 imageHeight = region.bufferImageCopy.imageExtent.height;
1414
1415         const int                       texelSize       = dst.getFormat().getPixelSize();
1416         const VkExtent3D        extent          = region.bufferImageCopy.imageExtent;
1417         const VkOffset3D        dstOffset       = region.bufferImageCopy.imageOffset;
1418         const int                       texelOffset     = (int) region.bufferImageCopy.bufferOffset / texelSize;
1419
1420         for (deUint32 z = 0; z < extent.depth; z++)
1421         {
1422                 for (deUint32 y = 0; y < extent.height; y++)
1423                 {
1424                         int                                                                     texelIndex              = texelOffset + (z * imageHeight + y) *  rowLength;
1425                         const tcu::ConstPixelBufferAccess       srcSubRegion    = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1426                         const tcu::PixelBufferAccess            dstSubRegion    = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1427                                                                                                                                                                         region.bufferImageCopy.imageExtent.width, 1, 1);
1428                         tcu::copy(dstSubRegion, srcSubRegion);
1429                 }
1430         }
1431 }
1432
1433 } // anonymous
1434
1435 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
1436 {
1437         de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests  (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
1438
1439         const VkExtent3D                                defaultExtent                   = {256, 256, 1};
1440         const VkImageSubresourceLayers  defaultSourceLayer              =
1441         {
1442                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1443                 0u,                                                     // uint32_t                             mipLevel;
1444                 0u,                                                     // uint32_t                             baseArrayLayer;
1445                 1u,                                                     // uint32_t                             layerCount;
1446         };
1447
1448         {
1449                 std::ostringstream description;
1450                 description << "Copy from image to image";
1451
1452                 TestParams      params;
1453                 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1454                 params.src.image.extent = defaultExtent;
1455                 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1456                 params.dst.image.extent = defaultExtent;
1457
1458                 {
1459                         const VkImageSubresourceLayers sourceLayer =
1460                         {
1461                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1462                                 0u,                                                     // uint32_t                             mipLevel;
1463                                 0u,                                                     // uint32_t                             baseArrayLayer;
1464                                 1u                                                      // uint32_t                             layerCount;
1465                         };
1466                         const VkImageCopy testCopy =
1467                         {
1468                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
1469                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
1470                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
1471                                 {0, 0, 0},              // VkOffset3D                           dstOffset;
1472                                 {256, 256, 1},  // VkExtent3D                           extent;
1473                         };
1474
1475                         CopyRegion imageCopy;
1476                         imageCopy.imageCopy = testCopy;
1477
1478                         params.regions.push_back(imageCopy);
1479                 }
1480
1481                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "imageToImage_whole", description.str(), params));
1482         }
1483
1484         {
1485                 std::ostringstream description;
1486                 description << "Copy from image to image";
1487
1488                 TestParams      params;
1489                 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1490                 params.src.image.extent = defaultExtent;
1491                 params.dst.image.format = VK_FORMAT_R32_UINT;
1492                 params.dst.image.extent = defaultExtent;
1493
1494                 {
1495                         const VkImageSubresourceLayers sourceLayer =
1496                         {
1497                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1498                                 0u,                                                     // uint32_t                             mipLevel;
1499                                 0u,                                                     // uint32_t                             baseArrayLayer;
1500                                 1u                                                      // uint32_t                             layerCount;
1501                         };
1502                         const VkImageCopy testCopy =
1503                         {
1504                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
1505                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
1506                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
1507                                 {0, 0, 0},              // VkOffset3D                           dstOffset;
1508                                 {256, 256, 1},  // VkExtent3D                           extent;
1509                         };
1510
1511                         CopyRegion imageCopy;
1512                         imageCopy.imageCopy = testCopy;
1513
1514                         params.regions.push_back(imageCopy);
1515                 }
1516
1517                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_whole_different_format_uncompressed", description.str(), params));
1518         }
1519
1520         {
1521                 std::ostringstream description;
1522                 description << "Copy from image to image";
1523
1524                 TestParams      params;
1525                 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1526                 params.src.image.extent = defaultExtent;
1527                 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1528                 params.dst.image.extent = defaultExtent;
1529
1530                 {
1531                         const VkImageSubresourceLayers sourceLayer =
1532                         {
1533                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1534                                 0u,                                                     // uint32_t                             mipLevel;
1535                                 0u,                                                     // uint32_t                             baseArrayLayer;
1536                                 1u                                                      // uint32_t                             layerCount;
1537                         };
1538                         const VkImageCopy testCopy =
1539                         {
1540                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
1541                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
1542                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
1543                                 {64, 98, 0},    // VkOffset3D                           dstOffset;
1544                                 {16, 16, 1},    // VkExtent3D                           extent;
1545                         };
1546
1547                         CopyRegion imageCopy;
1548                         imageCopy.imageCopy = testCopy;
1549
1550                         params.regions.push_back(imageCopy);
1551                 }
1552
1553                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_partial", description.str(), params));
1554         }
1555
1556         {
1557                 std::ostringstream description;
1558                 description << "Copy from image to image";
1559
1560                 TestParams      params;
1561                 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1562                 params.src.image.extent = defaultExtent;
1563                 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1564                 params.dst.image.extent = defaultExtent;
1565
1566                 for (deInt32 i = 0; i < 16; i++)
1567                 {
1568                         const VkImageSubresourceLayers sourceLayer =
1569                         {
1570                                 VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
1571                                 0u,                                                     // uint32_t                             mipLevel;
1572                                 0u,                                                     // uint32_t                             baseArrayLayer;
1573                                 1u                                                      // uint32_t                             layerCount;
1574                         };
1575                         const VkImageCopy testCopy =
1576                         {
1577                                 sourceLayer,                    // VkImageSubresourceLayers     srcSubresource;
1578                                 {0, 0, 0},                              // VkOffset3D                           srcOffset;
1579                                 sourceLayer,                    // VkImageSubresourceLayers     dstSubresource;
1580                                 {i*16, 240-i*16, 0},    // VkOffset3D                           dstOffset;
1581                                 {16, 16, 1},                    // VkExtent3D                           extent;
1582                         };
1583
1584                         CopyRegion imageCopy;
1585                         imageCopy.imageCopy = testCopy;
1586
1587                         params.regions.push_back(imageCopy);
1588                 }
1589
1590                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_partial_multiple", description.str(), params));
1591         }
1592
1593         // Copy image to buffer testcases.
1594         {
1595                 std::ostringstream      description;
1596                 description << "Copy from image to buffer";
1597
1598                 TestParams      params;
1599                 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1600                 params.src.image.extent = defaultExtent;
1601                 params.dst.buffer.size  = 256 * 256;
1602
1603                 const VkBufferImageCopy                 bufferImageCopy =
1604                 {
1605                         0u,                                             // VkDeviceSize                         bufferOffset;
1606                         0u,                                             // uint32_t                                     bufferRowLength;
1607                         0u,                                             // uint32_t                                     bufferImageHeight;
1608                         defaultSourceLayer,             // VkImageSubresourceLayers     imageSubresource;
1609                         {0, 0, 0},                              // VkOffset3D                           imageOffset;
1610                         {16, 16, 1}                             // VkExtent3D                           imageExtent;
1611                 };
1612                 CopyRegion copyRegion;
1613                 copyRegion.bufferImageCopy = bufferImageCopy;
1614
1615                 params.regions.push_back(copyRegion);
1616
1617                 copiesAndBlittingTests->addChild(new CopyImageToBufferTestCase(testCtx, "image_to_buffer", description.str(), params));
1618         }
1619
1620         // Copy buffer to image testcases.
1621         {
1622                 std::ostringstream      description;
1623                 description << "Copy from buffer to image";
1624
1625                 TestParams      params;
1626                 params.src.buffer.size  = 256 * 256;
1627                 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1628                 params.dst.image.extent = defaultExtent;
1629
1630                 const VkBufferImageCopy                 bufferImageCopy =
1631                 {
1632                         0u,                                             // VkDeviceSize                         bufferOffset;
1633                         0u,                                             // uint32_t                                     bufferRowLength;
1634                         0u,                                             // uint32_t                                     bufferImageHeight;
1635                         defaultSourceLayer,             // VkImageSubresourceLayers     imageSubresource;
1636                         {0, 0, 0},                              // VkOffset3D                           imageOffset;
1637                         {16, 16, 1}                             // VkExtent3D                           imageExtent;
1638                 };
1639                 CopyRegion copyRegion;
1640                 copyRegion.bufferImageCopy = bufferImageCopy;
1641
1642                 params.regions.push_back(copyRegion);
1643
1644                 copiesAndBlittingTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_to_image", description.str(), params));
1645         }
1646
1647         {
1648                 std::ostringstream      description;
1649                 description << "Copy from buffer to buffer: whole buffer.";
1650
1651                 TestParams params;
1652                 params.src.buffer.size = 256;
1653                 params.dst.buffer.size = 256;
1654                 const VkBufferCopy bufferCopy = {
1655                         0u,             // VkDeviceSize srcOffset;
1656                         0u,             // VkDeviceSize dstOffset;
1657                         256u,   // VkDeviceSize size;
1658                 };
1659                 CopyRegion copyRegion;
1660                 copyRegion.bufferCopy = bufferCopy;
1661
1662                 params.regions.push_back(copyRegion);
1663
1664                 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_whole", description.str(), params));
1665         }
1666
1667         {
1668                 std::ostringstream      description;
1669                 description << "Copy from buffer to buffer: small area.";
1670
1671                 TestParams params;
1672                 params.src.buffer.size = 16;
1673                 params.dst.buffer.size = 16;
1674                 const VkBufferCopy bufferCopy = {
1675                         12u,    // VkDeviceSize srcOffset;
1676                         4u,             // VkDeviceSize dstOffset;
1677                         1u,             // VkDeviceSize size;
1678                 };
1679                 CopyRegion copyRegion;
1680                 copyRegion.bufferCopy = bufferCopy;
1681
1682                 params.regions.push_back(copyRegion);
1683
1684                 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_small", description.str(), params));
1685         }
1686
1687         {
1688                 std::ostringstream      description;
1689                 description << "Copy from buffer to buffer: more regions.";
1690
1691                 const deUint32 size = 16;
1692
1693                 TestParams params;
1694                 params.src.buffer.size = size;
1695                 params.dst.buffer.size = size * (size + 1);
1696
1697                 // Copy region with size 1..size
1698                 for (unsigned int i = 1; i <= size; i++)
1699                 {
1700                         const VkBufferCopy bufferCopy = {
1701                                 0,              // VkDeviceSize srcOffset;
1702                                 i*size, // VkDeviceSize dstOffset;
1703                                 i,              // VkDeviceSize size;
1704                         };
1705                         CopyRegion copyRegion;
1706                         copyRegion.bufferCopy = bufferCopy;
1707                         params.regions.push_back(copyRegion);
1708                 }
1709                 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_regions", description.str(), params));
1710         }
1711
1712         {
1713                 std::ostringstream description;
1714                 description << "Copy from image to image depth";
1715
1716                 TestParams      params;
1717                 params.src.image.format = VK_FORMAT_D32_SFLOAT;
1718                 params.src.image.extent = defaultExtent;
1719                 params.dst.image.format = VK_FORMAT_D32_SFLOAT;
1720                 params.dst.image.extent = defaultExtent;
1721
1722                 {
1723                         const VkImageSubresourceLayers sourceLayer =
1724                         {
1725                                 VK_IMAGE_ASPECT_DEPTH_BIT,      // VkImageAspectFlags   aspectMask;
1726                                 0u,                                                     // uint32_t                             mipLevel;
1727                                 0u,                                                     // uint32_t                             baseArrayLayer;
1728                                 1u                                                      // uint32_t                             layerCount;
1729                         };
1730                         const VkImageCopy testCopy =
1731                         {
1732                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
1733                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
1734                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
1735                                 {64, 98, 0},    // VkOffset3D                           dstOffset;
1736                                 {16, 16, 1},    // VkExtent3D                           extent;
1737                         };
1738
1739                         CopyRegion imageCopy;
1740                         imageCopy.imageCopy = testCopy;
1741
1742                         params.regions.push_back(imageCopy);
1743                 }
1744
1745                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_depth", description.str(), params));
1746         }
1747
1748         {
1749                 std::ostringstream description;
1750                 description << "Copy from image to image stencil";
1751
1752                 TestParams      params;
1753                 params.src.image.format = VK_FORMAT_S8_UINT;
1754                 params.src.image.extent = defaultExtent;
1755                 params.dst.image.format = VK_FORMAT_S8_UINT;
1756                 params.dst.image.extent = defaultExtent;
1757
1758                 {
1759                         const VkImageSubresourceLayers sourceLayer =
1760                         {
1761                                 VK_IMAGE_ASPECT_STENCIL_BIT,    // VkImageAspectFlags   aspectMask;
1762                                 0u,                                                             // uint32_t                             mipLevel;
1763                                 0u,                                                             // uint32_t                             baseArrayLayer;
1764                                 1u                                                              // uint32_t                             layerCount;
1765                         };
1766                         const VkImageCopy testCopy =
1767                         {
1768                                 sourceLayer,    // VkImageSubresourceLayers     srcSubresource;
1769                                 {0, 0, 0},              // VkOffset3D                           srcOffset;
1770                                 sourceLayer,    // VkImageSubresourceLayers     dstSubresource;
1771                                 {64, 98, 0},    // VkOffset3D                           dstOffset;
1772                                 {16, 16, 1},    // VkExtent3D                           extent;
1773                         };
1774
1775                         CopyRegion imageCopy;
1776                         imageCopy.imageCopy = testCopy;
1777
1778                         params.regions.push_back(imageCopy);
1779                 }
1780
1781                 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_stencil", description.str(), params));
1782         }
1783
1784         return copiesAndBlittingTests.release();
1785 }
1786
1787 } // api
1788 } // vkt