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

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