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

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