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

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