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

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