1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015-2016 The Khronos Group Inc.
6 * Copyright (c) 2015-2016 Samsung Electronics Co., Ltd.
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 * \brief Vulkan Copies And Blitting Tests
23 *//*--------------------------------------------------------------------*/
25 #include "vktApiCopiesAndBlittingTests.hpp"
27 #include "deStringUtil.hpp"
28 #include "deUniquePtr.hpp"
30 #include "tcuImageCompare.hpp"
31 #include "tcuTexture.hpp"
32 #include "tcuTextureUtil.hpp"
33 #include "tcuVectorType.hpp"
34 #include "tcuVectorUtil.hpp"
36 #include "vkImageUtil.hpp"
37 #include "vkMemUtil.hpp"
38 #include "vkPrograms.hpp"
39 #include "vkQueryUtil.hpp"
40 #include "vkRefUtil.hpp"
41 #include "vktTestCase.hpp"
42 #include "vktTestCaseUtil.hpp"
43 #include "vkTypeUtil.hpp"
56 MIRROR_MODE_X = (1<<0),
57 MIRROR_MODE_Y = (1<<1),
58 MIRROR_MODE_XY = MIRROR_MODE_X | MIRROR_MODE_Y,
70 VkImageAspectFlags getAspectFlags (tcu::TextureFormat format)
72 VkImageAspectFlags aspectFlag = 0;
73 aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
74 aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
77 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
82 // This is effectively same as vk::isFloatFormat(mapTextureFormat(format))
83 // except that it supports some formats that are not mappable to VkFormat.
84 // When we are checking combined depth and stencil formats, each aspect is
85 // checked separately, and in some cases we construct PBA with a format that
86 // is not mappable to VkFormat.
87 bool isFloatFormat (tcu::TextureFormat format)
89 return tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
94 VkBufferCopy bufferCopy;
95 VkImageCopy imageCopy;
96 VkBufferImageCopy bufferImageCopy;
97 VkImageBlit imageBlit;
98 VkImageResolve imageResolve;
103 VkImageType imageType;
120 std::vector<CopyRegion> regions;
125 VkSampleCountFlagBits samples;
129 inline deUint32 getArraySize(const ImageParms& parms)
131 return (parms.imageType == VK_IMAGE_TYPE_2D) ? parms.extent.depth : 1u;
134 inline VkExtent3D getExtent3D(const ImageParms& parms)
136 const VkExtent3D extent =
140 (parms.imageType == VK_IMAGE_TYPE_2D) ? 1u : parms.extent.depth
145 const tcu::TextureFormat mapCombinedToDepthTransferFormat (const tcu::TextureFormat& combinedFormat)
147 tcu::TextureFormat format;
148 switch (combinedFormat.type)
150 case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
151 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
153 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
154 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNSIGNED_INT_24_8_REV);
156 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
157 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
166 class CopiesAndBlittingTestInstance : public vkt::TestInstance
169 CopiesAndBlittingTestInstance (Context& context,
170 TestParams testParams);
171 virtual tcu::TestStatus iterate (void) = 0;
175 FILL_MODE_GRADIENT = 0,
178 FILL_MODE_MULTISAMPLE,
184 const TestParams m_params;
186 Move<VkCommandPool> m_cmdPool;
187 Move<VkCommandBuffer> m_cmdBuffer;
188 Move<VkFence> m_fence;
189 de::MovePtr<tcu::TextureLevel> m_sourceTextureLevel;
190 de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
191 de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
193 VkCommandBufferBeginInfo m_cmdBufferBeginInfo;
195 void generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_GRADIENT);
196 virtual void generateExpectedResult (void);
197 void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
198 void uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms);
199 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
200 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
201 deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
203 return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
206 de::MovePtr<tcu::TextureLevel> readImage (vk::VkImage image,
207 const ImageParms& imageParms);
208 void submitCommandsAndWait (const DeviceInterface& vk,
209 const VkDevice device,
211 const VkCommandBuffer& cmdBuffer);
214 void uploadImageAspect (const tcu::ConstPixelBufferAccess& src,
216 const ImageParms& parms);
217 void readImageAspect (vk::VkImage src,
218 const tcu::PixelBufferAccess& dst,
219 const ImageParms& parms);
222 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
223 : vkt::TestInstance (context)
224 , m_params (testParams)
226 const DeviceInterface& vk = context.getDeviceInterface();
227 const VkDevice vkDevice = context.getDevice();
228 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
230 // Create command pool
232 const VkCommandPoolCreateInfo cmdPoolParams =
234 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
235 DE_NULL, // const void* pNext;
236 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,// VkCmdPoolCreateFlags flags;
237 queueFamilyIndex, // deUint32 queueFamilyIndex;
240 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
243 // Create command buffer
245 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
247 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
248 DE_NULL, // const void* pNext;
249 *m_cmdPool, // VkCommandPool commandPool;
250 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
251 1u // deUint32 bufferCount;
254 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
259 const VkFenceCreateInfo fenceParams =
261 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
262 DE_NULL, // const void* pNext;
263 0u // VkFenceCreateFlags flags;
266 m_fence = createFence(vk, vkDevice, &fenceParams);
270 void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
272 if (mode == FILL_MODE_GRADIENT)
274 tcu::fillWithComponentGradients(buffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
278 const tcu::Vec4 redColor (1.0, 0.0, 0.0, 1.0);
279 const tcu::Vec4 greenColor (0.0, 1.0, 0.0, 1.0);
280 const tcu::Vec4 blueColor (0.0, 0.0, 1.0, 1.0);
281 const tcu::Vec4 whiteColor (1.0, 1.0, 1.0, 1.0);
283 for (int z = 0; z < depth; z++)
285 for (int y = 0; y < height; y++)
287 for (int x = 0; x < width; x++)
291 case FILL_MODE_WHITE:
292 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
294 buffer.setPixDepth(1.0f, x, y, z);
295 if (tcu::hasStencilComponent(buffer.getFormat().order))
296 buffer.setPixStencil(255, x, y, z);
299 buffer.setPixel(whiteColor, x, y, z);
302 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
304 buffer.setPixDepth(redColor[x % 4], x, y, z);
305 if (tcu::hasStencilComponent(buffer.getFormat().order))
306 buffer.setPixStencil(255 * (int)redColor[y % 4], x, y, z);
309 buffer.setPixel(redColor, x, y, z);
311 case FILL_MODE_MULTISAMPLE:
312 buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
322 void CopiesAndBlittingTestInstance::uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
324 const DeviceInterface& vk = m_context.getDeviceInterface();
325 const VkDevice vkDevice = m_context.getDevice();
326 const deUint32 bufferSize = calculateSize(bufferAccess);
329 deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
330 flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
333 void CopiesAndBlittingTestInstance::uploadImageAspect (const tcu::ConstPixelBufferAccess& imageAccess, const VkImage& image, const ImageParms& parms)
335 const DeviceInterface& vk = m_context.getDeviceInterface();
336 const VkDevice vkDevice = m_context.getDevice();
337 const VkQueue queue = m_context.getUniversalQueue();
338 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
339 Allocator& memAlloc = m_context.getDefaultAllocator();
340 Move<VkBuffer> buffer;
341 const deUint32 bufferSize = calculateSize(imageAccess);
342 de::MovePtr<Allocation> bufferAlloc;
343 const deUint32 arraySize = getArraySize(parms);
344 const VkExtent3D imageExtent = getExtent3D(parms);
346 // Create source buffer
348 const VkBufferCreateInfo bufferParams =
350 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
351 DE_NULL, // const void* pNext;
352 0u, // VkBufferCreateFlags flags;
353 bufferSize, // VkDeviceSize size;
354 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
355 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
356 1u, // deUint32 queueFamilyIndexCount;
357 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
360 buffer = createBuffer(vk, vkDevice, &bufferParams);
361 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
362 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
365 // Barriers for copying buffer to image
366 const VkBufferMemoryBarrier preBufferBarrier =
368 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
369 DE_NULL, // const void* pNext;
370 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
371 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
372 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
373 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
374 *buffer, // VkBuffer buffer;
375 0u, // VkDeviceSize offset;
376 bufferSize // VkDeviceSize size;
379 const VkImageAspectFlags aspect = getAspectFlags(imageAccess.getFormat());
380 const VkImageMemoryBarrier preImageBarrier =
382 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
383 DE_NULL, // const void* pNext;
384 0u, // VkAccessFlags srcAccessMask;
385 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
386 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
387 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
388 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
389 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
390 image, // VkImage image;
391 { // VkImageSubresourceRange subresourceRange;
392 aspect, // VkImageAspectFlags aspect;
393 0u, // deUint32 baseMipLevel;
394 1u, // deUint32 mipLevels;
395 0u, // deUint32 baseArraySlice;
396 arraySize, // deUint32 arraySize;
400 const VkImageMemoryBarrier postImageBarrier =
402 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
403 DE_NULL, // const void* pNext;
404 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
405 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
406 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
407 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
408 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
409 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
410 image, // VkImage image;
411 { // VkImageSubresourceRange subresourceRange;
412 aspect, // VkImageAspectFlags aspect;
413 0u, // deUint32 baseMipLevel;
414 1u, // deUint32 mipLevels;
415 0u, // deUint32 baseArraySlice;
416 arraySize, // deUint32 arraySize;
420 const VkBufferImageCopy copyRegion =
422 0u, // VkDeviceSize bufferOffset;
423 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
424 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
426 getAspectFlags(imageAccess.getFormat()), // VkImageAspectFlags aspect;
427 0u, // deUint32 mipLevel;
428 0u, // deUint32 baseArrayLayer;
429 arraySize, // deUint32 layerCount;
430 }, // VkImageSubresourceLayers imageSubresource;
431 { 0, 0, 0 }, // VkOffset3D imageOffset;
432 imageExtent // VkExtent3D imageExtent;
436 deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
437 flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
439 // Copy buffer to image
440 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
442 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
443 DE_NULL, // const void* pNext;
444 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
445 (const VkCommandBufferInheritanceInfo*)DE_NULL,
448 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
449 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
450 vk.cmdCopyBufferToImage(*m_cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
451 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);
452 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
454 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
457 void CopiesAndBlittingTestInstance::uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms)
459 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
461 if (tcu::hasDepthComponent(src.getFormat().order))
463 tcu::TextureLevel depthTexture (mapCombinedToDepthTransferFormat(src.getFormat()), src.getWidth(), src.getHeight(), src.getDepth());
464 tcu::copy(depthTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH));
465 uploadImageAspect(depthTexture.getAccess(), dst, parms);
468 if (tcu::hasStencilComponent(src.getFormat().order))
470 tcu::TextureLevel stencilTexture (tcu::getEffectiveDepthStencilTextureFormat(src.getFormat(), tcu::Sampler::MODE_STENCIL), src.getWidth(), src.getHeight(), src.getDepth());
471 tcu::copy(stencilTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL));
472 uploadImageAspect(stencilTexture.getAccess(), dst, parms);
476 uploadImageAspect(src, dst, parms);
479 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult (tcu::ConstPixelBufferAccess result)
481 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
483 if (isFloatFormat(result.getFormat()))
485 const tcu::Vec4 threshold (0.0f);
486 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
487 return tcu::TestStatus::fail("CopiesAndBlitting test");
491 const tcu::UVec4 threshold (0u);
492 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
493 return tcu::TestStatus::fail("CopiesAndBlitting test");
496 return tcu::TestStatus::pass("CopiesAndBlitting test");
499 void CopiesAndBlittingTestInstance::generateExpectedResult (void)
501 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
502 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
504 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
505 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
507 for (deUint32 i = 0; i < m_params.regions.size(); i++)
508 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
511 class CopiesAndBlittingTestCase : public vkt::TestCase
514 CopiesAndBlittingTestCase (tcu::TestContext& testCtx,
515 const std::string& name,
516 const std::string& description)
517 : vkt::TestCase (testCtx, name, description)
520 virtual TestInstance* createInstance (Context& context) const = 0;
523 void CopiesAndBlittingTestInstance::readImageAspect (vk::VkImage image,
524 const tcu::PixelBufferAccess& dst,
525 const ImageParms& imageParms)
527 const DeviceInterface& vk = m_context.getDeviceInterface();
528 const VkDevice device = m_context.getDevice();
529 const VkQueue queue = m_context.getUniversalQueue();
530 Allocator& allocator = m_context.getDefaultAllocator();
532 Move<VkBuffer> buffer;
533 de::MovePtr<Allocation> bufferAlloc;
534 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
535 const VkDeviceSize pixelDataSize = calculateSize(dst);
536 const VkExtent3D imageExtent = getExtent3D(imageParms);
538 // Create destination buffer
540 const VkBufferCreateInfo bufferParams =
542 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
543 DE_NULL, // const void* pNext;
544 0u, // VkBufferCreateFlags flags;
545 pixelDataSize, // VkDeviceSize size;
546 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
547 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
548 1u, // deUint32 queueFamilyIndexCount;
549 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
552 buffer = createBuffer(vk, device, &bufferParams);
553 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
554 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
556 deMemset(bufferAlloc->getHostPtr(), 0, static_cast<size_t>(pixelDataSize));
557 flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
560 // Barriers for copying image to buffer
561 const VkImageAspectFlags aspect = getAspectFlags(dst.getFormat());
562 const VkImageMemoryBarrier imageBarrier =
564 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
565 DE_NULL, // const void* pNext;
566 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
567 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
568 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
569 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
570 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
571 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
572 image, // VkImage image;
573 { // VkImageSubresourceRange subresourceRange;
574 aspect, // VkImageAspectFlags aspectMask;
575 0u, // deUint32 baseMipLevel;
576 1u, // deUint32 mipLevels;
577 0u, // deUint32 baseArraySlice;
578 getArraySize(imageParms)// deUint32 arraySize;
582 const VkBufferMemoryBarrier bufferBarrier =
584 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
585 DE_NULL, // const void* pNext;
586 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
587 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
588 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
589 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
590 *buffer, // VkBuffer buffer;
591 0u, // VkDeviceSize offset;
592 pixelDataSize // VkDeviceSize size;
595 const VkImageMemoryBarrier postImageBarrier =
597 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
598 DE_NULL, // const void* pNext;
599 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags srcAccessMask;
600 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
601 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout oldLayout;
602 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
603 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
604 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
605 image, // VkImage image;
607 aspect, // VkImageAspectFlags aspectMask;
608 0u, // deUint32 baseMipLevel;
609 1u, // deUint32 mipLevels;
610 0u, // deUint32 baseArraySlice;
611 getArraySize(imageParms) // deUint32 arraySize;
612 } // VkImageSubresourceRange subresourceRange;
615 // Copy image to buffer
616 const VkBufferImageCopy copyRegion =
618 0u, // VkDeviceSize bufferOffset;
619 (deUint32)dst.getWidth(), // deUint32 bufferRowLength;
620 (deUint32)dst.getHeight(), // deUint32 bufferImageHeight;
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;
631 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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, ©Region);
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));
645 submitCommandsAndWait(vk, device, queue, *m_cmdBuffer);
648 invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
649 tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferAlloc->getHostPtr()));
652 void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
654 const VkSubmitInfo submitInfo =
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;
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 */));
672 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (vk::VkImage image,
673 const ImageParms& parms)
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));
678 if (tcu::isCombinedDepthStencilType(imageFormat.type))
680 if (tcu::hasDepthComponent(imageFormat.order))
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());
687 if (tcu::hasStencilComponent(imageFormat.order))
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());
695 readImageAspect(image, resultLevel->getAccess(), parms);
700 // Copy from image to image.
702 class CopyImageToImage : public CopiesAndBlittingTestInstance
705 CopyImageToImage (Context& context,
707 virtual tcu::TestStatus iterate (void);
710 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
713 Move<VkImage> m_source;
714 de::MovePtr<Allocation> m_sourceImageAlloc;
715 Move<VkImage> m_destination;
716 de::MovePtr<Allocation> m_destinationImageAlloc;
718 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
721 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
722 : CopiesAndBlittingTestInstance(context, params)
724 const DeviceInterface& vk = context.getDeviceInterface();
725 const VkDevice vkDevice = context.getDevice();
726 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
727 Allocator& memAlloc = context.getDefaultAllocator();
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))
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");
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,
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,
750 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
752 TCU_THROW(NotSupportedError, "Format not supported");
755 // Create source image
757 const VkImageCreateInfo sourceImageParams =
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;
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()));
782 // Create destination image
784 const VkImageCreateInfo destinationImageParams =
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;
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()));
810 tcu::TestStatus CopyImageToImage::iterate (void)
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();
826 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
827 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
829 const DeviceInterface& vk = m_context.getDeviceInterface();
830 const VkDevice vkDevice = m_context.getDevice();
831 const VkQueue queue = m_context.getUniversalQueue();
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);
837 const VkImageMemoryBarrier imageBarriers[] =
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;
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;
879 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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));
892 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
894 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
896 return checkTestResult(resultTextureLevel->getAccess());
899 tcu::TestStatus CopyImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
901 const tcu::Vec4 fThreshold (0.0f);
902 const tcu::UVec4 uThreshold (0u);
904 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
906 if (tcu::hasDepthComponent(result.getFormat().order))
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);
912 if (isFloatFormat(result.getFormat()))
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");
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");
924 if (tcu::hasStencilComponent(result.getFormat().order))
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);
930 if (isFloatFormat(result.getFormat()))
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");
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");
944 if (isFloatFormat(result.getFormat()))
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");
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");
956 return tcu::TestStatus::pass("CopiesAndBlitting test");
959 void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
961 VkOffset3D srcOffset = region.imageCopy.srcOffset;
962 VkOffset3D dstOffset = region.imageCopy.dstOffset;
963 VkExtent3D extent = region.imageCopy.extent;
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)
969 srcOffset.z = dstOffset.z;
970 extent.depth = std::max(region.imageCopy.extent.depth, region.imageCopy.srcSubresource.layerCount);
974 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
976 DE_ASSERT(src.getFormat() == dst.getFormat());
979 if (tcu::hasDepthComponent(src.getFormat().order))
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);
987 if (tcu::hasStencilComponent(src.getFormat().order))
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);
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);
1001 tcu::copy(dstSubRegion, srcSubRegion);
1005 class CopyImageToImageTestCase : public vkt::TestCase
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)
1016 virtual TestInstance* createInstance (Context& context) const
1018 return new CopyImageToImage(context, m_params);
1021 TestParams m_params;
1024 // Copy from buffer to buffer.
1026 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
1029 CopyBufferToBuffer (Context& context, TestParams params);
1030 virtual tcu::TestStatus iterate (void);
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;
1039 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
1040 : CopiesAndBlittingTestInstance (context, params)
1042 const DeviceInterface& vk = context.getDeviceInterface();
1043 const VkDevice vkDevice = context.getDevice();
1044 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1045 Allocator& memAlloc = context.getDefaultAllocator();
1047 // Create source buffer
1049 const VkBufferCreateInfo sourceBufferParams =
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;
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()));
1066 // Create destination buffer
1068 const VkBufferCreateInfo destinationBufferParams =
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;
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()));
1086 tcu::TestStatus CopyBufferToBuffer::iterate (void)
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);
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);
1096 generateExpectedResult();
1098 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1099 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1101 const DeviceInterface& vk = m_context.getDeviceInterface();
1102 const VkDevice vkDevice = m_context.getDevice();
1103 const VkQueue queue = m_context.getUniversalQueue();
1105 const VkBufferMemoryBarrier srcBufferBarrier =
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;
1118 const VkBufferMemoryBarrier dstBufferBarrier =
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;
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);
1135 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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);
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()));
1157 return checkTestResult(resultLevel->getAccess());
1160 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1162 deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
1163 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
1164 (size_t)region.bufferCopy.size);
1167 class BufferToBufferTestCase : public vkt::TestCase
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)
1178 virtual TestInstance* createInstance (Context& context) const
1180 return new CopyBufferToBuffer(context, m_params);
1183 TestParams m_params;
1186 // Copy from image to buffer.
1188 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1191 CopyImageToBuffer (Context& context,
1192 TestParams testParams);
1193 virtual tcu::TestStatus iterate (void);
1195 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1197 tcu::TextureFormat m_textureFormat;
1198 VkDeviceSize m_bufferSize;
1200 Move<VkImage> m_source;
1201 de::MovePtr<Allocation> m_sourceImageAlloc;
1202 Move<VkBuffer> m_destination;
1203 de::MovePtr<Allocation> m_destinationBufferAlloc;
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))
1211 const DeviceInterface& vk = context.getDeviceInterface();
1212 const VkDevice vkDevice = context.getDevice();
1213 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1214 Allocator& memAlloc = context.getDefaultAllocator();
1216 // Create source image
1218 const VkImageCreateInfo sourceImageParams =
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;
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()));
1243 // Create destination buffer
1245 const VkBufferCreateInfo destinationBufferParams =
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;
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()));
1263 tcu::TestStatus CopyImageToBuffer::iterate (void)
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);
1273 generateExpectedResult();
1275 uploadImage(m_sourceTextureLevel->getAccess(), *m_source, m_params.src.image);
1276 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1278 const DeviceInterface& vk = m_context.getDeviceInterface();
1279 const VkDevice vkDevice = m_context.getDevice();
1280 const VkQueue queue = m_context.getUniversalQueue();
1282 // Barriers for copying image to buffer
1283 const VkImageMemoryBarrier imageBarrier =
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;
1303 const VkBufferMemoryBarrier bufferBarrier =
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;
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);
1321 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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));
1335 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
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()));
1342 return checkTestResult(resultLevel->getAccess());
1345 class CopyImageToBufferTestCase : public vkt::TestCase
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)
1356 virtual TestInstance* createInstance (Context& context) const
1358 return new CopyImageToBuffer(context, m_params);
1361 TestParams m_params;
1364 void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1366 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1368 rowLength = region.bufferImageCopy.imageExtent.width;
1370 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1372 imageHeight = region.bufferImageCopy.imageExtent.height;
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;
1379 for (deUint32 z = 0; z < extent.depth; z++)
1381 for (deUint32 y = 0; y < extent.height; y++)
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);
1392 // Copy from buffer to image.
1394 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1397 CopyBufferToImage (Context& context,
1398 TestParams testParams);
1399 virtual tcu::TestStatus iterate (void);
1401 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1403 tcu::TextureFormat m_textureFormat;
1404 VkDeviceSize m_bufferSize;
1406 Move<VkBuffer> m_source;
1407 de::MovePtr<Allocation> m_sourceBufferAlloc;
1408 Move<VkImage> m_destination;
1409 de::MovePtr<Allocation> m_destinationImageAlloc;
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))
1417 const DeviceInterface& vk = context.getDeviceInterface();
1418 const VkDevice vkDevice = context.getDevice();
1419 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1420 Allocator& memAlloc = context.getDefaultAllocator();
1422 // Create source buffer
1424 const VkBufferCreateInfo sourceBufferParams =
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;
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()));
1441 // Create destination image
1443 const VkImageCreateInfo destinationImageParams =
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;
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()));
1469 tcu::TestStatus CopyBufferToImage::iterate (void)
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));
1478 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
1480 generateExpectedResult();
1482 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1483 uploadImage(m_destinationTextureLevel->getAccess(), *m_destination, m_params.dst.image);
1485 const DeviceInterface& vk = m_context.getDeviceInterface();
1486 const VkDevice vkDevice = m_context.getDevice();
1487 const VkQueue queue = m_context.getUniversalQueue();
1489 const VkImageMemoryBarrier imageBarrier =
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;
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);
1514 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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));
1527 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1529 de::MovePtr<tcu::TextureLevel> resultLevel = readImage(*m_destination, m_params.dst.image);
1531 return checkTestResult(resultLevel->getAccess());
1534 class CopyBufferToImageTestCase : public vkt::TestCase
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)
1545 virtual ~CopyBufferToImageTestCase (void) {}
1547 virtual TestInstance* createInstance (Context& context) const
1549 return new CopyBufferToImage(context, m_params);
1552 TestParams m_params;
1555 void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1557 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1559 rowLength = region.bufferImageCopy.imageExtent.width;
1561 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1563 imageHeight = region.bufferImageCopy.imageExtent.height;
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;
1570 for (deUint32 z = 0; z < extent.depth; z++)
1572 for (deUint32 y = 0; y < extent.height; y++)
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);
1583 // Copy from image to image with scaling.
1585 class BlittingImages : public CopiesAndBlittingTestInstance
1588 BlittingImages (Context& context,
1590 virtual tcu::TestStatus iterate (void);
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);
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;
1605 de::MovePtr<tcu::TextureLevel> m_unclampedExpectedTextureLevel;
1608 BlittingImages::BlittingImages (Context& context, TestParams params)
1609 : CopiesAndBlittingTestInstance(context, params)
1611 const DeviceInterface& vk = context.getDeviceInterface();
1612 const VkDevice vkDevice = context.getDevice();
1613 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1614 Allocator& memAlloc = context.getDefaultAllocator();
1616 VkImageFormatProperties properties;
1617 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1618 m_params.src.image.format,
1620 VK_IMAGE_TILING_OPTIMAL,
1621 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1623 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
1624 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1625 m_params.dst.image.format,
1627 VK_IMAGE_TILING_OPTIMAL,
1628 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1630 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
1632 TCU_THROW(NotSupportedError, "Format not supported");
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))
1639 TCU_THROW(NotSupportedError, "Format feature blit source not supported");
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))
1646 TCU_THROW(NotSupportedError, "Format feature blit destination not supported");
1649 if (m_params.filter == VK_FILTER_LINEAR)
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");
1657 // Create source image
1659 const VkImageCreateInfo sourceImageParams =
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;
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()));
1684 // Create destination image
1686 const VkImageCreateInfo destinationImageParams =
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;
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()));
1712 tcu::TestStatus BlittingImages::iterate (void)
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();
1728 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
1729 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
1731 const DeviceInterface& vk = m_context.getDeviceInterface();
1732 const VkDevice vkDevice = m_context.getDevice();
1733 const VkQueue queue = m_context.getUniversalQueue();
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);
1739 // Barriers for copying image to buffer
1740 const VkImageMemoryBarrier srcImageBarrier =
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;
1760 const VkImageMemoryBarrier dstImageBarrier =
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;
1780 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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(), ®ions[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);
1795 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
1797 return checkTestResult(resultTextureLevel->getAccess());
1800 static float calculateFloatConversionError (int srcBits)
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;
1808 return de::clamp<float>(error, 0.0f, 1.0f);
1814 tcu::Vec4 getFormatThreshold (const tcu::TextureFormat& format)
1816 tcu::Vec4 threshold(0.01f);
1818 switch (format.type)
1820 case tcu::TextureFormat::HALF_FLOAT:
1821 threshold = tcu::Vec4(0.005f);
1824 case tcu::TextureFormat::FLOAT:
1825 case tcu::TextureFormat::FLOAT64:
1826 threshold = tcu::Vec4(0.001f);
1829 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1830 threshold = tcu::Vec4(0.02f, 0.02f, 0.0625f, 1.0f);
1833 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1834 threshold = tcu::Vec4(0.05f, 0.05f, 0.05f, 1.0f);
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()));
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);
1852 tcu::TextureFormat getFormatAspect (VkFormat format, VkImageAspectFlagBits aspect)
1854 const tcu::TextureFormat baseFormat = mapVkFormat(format);
1856 if (isCombinedDepthStencilType(baseFormat.type))
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);
1863 DE_FATAL("Invalid aspect");
1869 bool BlittingImages::checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess& result,
1870 const tcu::ConstPixelBufferAccess& clampedExpected,
1871 const tcu::ConstPixelBufferAccess& unclampedExpected,
1872 VkImageAspectFlagBits aspect)
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();
1880 DE_ASSERT(dstFormat == getFormatAspect(m_params.dst.image.format, aspect));
1883 log << tcu::TestLog::Section("ClampedSourceImage", "Region with clamped edges on source image.");
1885 if (isFloatFormat(dstFormat))
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);
1892 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1895 log << tcu::TestLog::EndSection;
1897 if (!isOk && isLinear)
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;
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);
1912 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1915 log << tcu::TestLog::EndSection;
1917 if (!isOk && isLinear)
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;
1927 tcu::TestStatus BlittingImages::checkTestResult (tcu::ConstPixelBufferAccess result)
1929 DE_ASSERT(m_params.filter == VK_FILTER_NEAREST || m_params.filter == VK_FILTER_LINEAR);
1931 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
1933 if (tcu::hasDepthComponent(result.getFormat().order))
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();
1940 if (!checkClampedAndUnclampedResult(depthResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_DEPTH_BIT))
1942 return tcu::TestStatus::fail("CopiesAndBlitting test");
1946 if (tcu::hasStencilComponent(result.getFormat().order))
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();
1953 if (!checkClampedAndUnclampedResult(stencilResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_STENCIL_BIT))
1955 return tcu::TestStatus::fail("CopiesAndBlitting test");
1961 if (!checkClampedAndUnclampedResult(result, m_expectedTextureLevel->getAccess(), m_params.filter == VK_FILTER_LINEAR ? m_unclampedExpectedTextureLevel->getAccess() : tcu::ConstPixelBufferAccess(), VK_IMAGE_ASPECT_COLOR_BIT))
1963 return tcu::TestStatus::fail("CopiesAndBlitting test");
1967 return tcu::TestStatus::pass("CopiesAndBlitting test");
1970 tcu::Vec4 linearToSRGBIfNeeded (const tcu::TextureFormat& format, const tcu::Vec4& color)
1972 return isSRGB(format) ? linearToSRGB(color) : color;
1975 void scaleFromWholeSrcBuffer (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const VkOffset3D regionOffset, const VkOffset3D regionExtent, tcu::Sampler::FilterMode filter)
1977 DE_ASSERT(filter == tcu::Sampler::LINEAR);
1978 DE_ASSERT(dst.getDepth() == 1 && src.getDepth() == 1);
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);
1983 float sX = (float)regionExtent.x / (float)dst.getWidth();
1984 float sY = (float)regionExtent.y / (float)dst.getHeight();
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);
1991 void blit (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const tcu::Sampler::FilterMode filter, const MirrorMode mirrorMode)
1993 DE_ASSERT(filter == tcu::Sampler::NEAREST || filter == tcu::Sampler::LINEAR);
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);
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();
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;
2008 const int xOffset = (mirrorMode & MIRROR_MODE_X) ? dst.getWidth() - 1 : 0;
2009 const int yOffset = (mirrorMode & MIRROR_MODE_Y) ? dst.getHeight() - 1 : 0;
2011 if (dst.getDepth() == 1 && src.getDepth() == 1)
2013 for (int y = 0; y < dst.getHeight(); ++y)
2014 for (int x = 0; x < dst.getWidth(); ++x)
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);
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)
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);
2032 void flipCoordinates (CopyRegion& region, const MirrorMode mirrorMode)
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];
2039 if (mirrorMode > MIRROR_MODE_NONE && mirrorMode < MIRROR_MODE_LAST)
2042 region.imageBlit.srcOffsets[0].x = std::min(srcOffset0.x, srcOffset1.x);
2043 region.imageBlit.srcOffsets[0].y = std::min(srcOffset0.y, srcOffset1.y);
2045 region.imageBlit.srcOffsets[1].x = std::max(srcOffset0.x, srcOffset1.x);
2046 region.imageBlit.srcOffsets[1].y = std::max(srcOffset0.y, srcOffset1.y);
2049 region.imageBlit.dstOffsets[0].x = std::min(dstOffset0.x, dstOffset1.x);
2050 region.imageBlit.dstOffsets[0].y = std::min(dstOffset0.y, dstOffset1.y);
2052 region.imageBlit.dstOffsets[1].x = std::max(dstOffset0.x, dstOffset1.x);
2053 region.imageBlit.dstOffsets[1].y = std::max(dstOffset0.y, dstOffset1.y);
2057 MirrorMode getMirrorMode(const VkOffset3D x1, const VkOffset3D x2)
2059 if (x1.x >= x2.x && x1.y >= x2.y)
2061 return MIRROR_MODE_XY;
2063 else if (x1.x <= x2.x && x1.y <= x2.y)
2065 return MIRROR_MODE_NONE;
2067 else if (x1.x <= x2.x && x1.y >= x2.y)
2069 return MIRROR_MODE_Y;
2071 else if (x1.x >= x2.x && x1.y <= x2.y)
2073 return MIRROR_MODE_X;
2075 return MIRROR_MODE_LAST;
2078 MirrorMode getMirrorMode(const VkOffset3D s1, const VkOffset3D s2, const VkOffset3D d1, const VkOffset3D d2)
2080 const MirrorMode source = getMirrorMode(s1, s2);
2081 const MirrorMode destination = getMirrorMode(d1, d2);
2083 if (source == destination)
2085 return MIRROR_MODE_NONE;
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))
2090 return MIRROR_MODE_Y;
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))
2095 return MIRROR_MODE_X;
2097 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_NONE))
2099 return MIRROR_MODE_XY;
2101 return MIRROR_MODE_LAST;
2104 void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2106 const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
2107 region.imageBlit.srcOffsets[1],
2108 region.imageBlit.dstOffsets[0],
2109 region.imageBlit.dstOffsets[1]);
2111 flipCoordinates(region, mirrorMode);
2113 const VkOffset3D srcOffset = region.imageBlit.srcOffsets[0];
2114 const VkOffset3D srcExtent =
2116 region.imageBlit.srcOffsets[1].x - srcOffset.x,
2117 region.imageBlit.srcOffsets[1].y - srcOffset.y,
2118 region.imageBlit.srcOffsets[1].z - srcOffset.z
2120 const VkOffset3D dstOffset = region.imageBlit.dstOffsets[0];
2121 const VkOffset3D dstExtent =
2123 region.imageBlit.dstOffsets[1].x - dstOffset.x,
2124 region.imageBlit.dstOffsets[1].y - dstOffset.y,
2125 region.imageBlit.dstOffsets[1].z - dstOffset.z
2127 const tcu::Sampler::FilterMode filter = (m_params.filter == VK_FILTER_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
2129 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
2131 DE_ASSERT(src.getFormat() == dst.getFormat());
2133 if (tcu::hasDepthComponent(src.getFormat().order))
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);
2139 if (filter == tcu::Sampler::LINEAR)
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);
2148 if (tcu::hasStencilComponent(src.getFormat().order))
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);
2154 if (filter == tcu::Sampler::LINEAR)
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);
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);
2168 if (filter == tcu::Sampler::LINEAR)
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);
2176 void BlittingImages::generateExpectedResult (void)
2178 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
2179 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
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);
2184 if (m_params.filter == VK_FILTER_LINEAR)
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);
2190 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2192 CopyRegion region = m_params.regions[i];
2193 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), region);
2197 class BlittingTestCase : public vkt::TestCase
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)
2208 virtual TestInstance* createInstance (Context& context) const
2210 return new BlittingImages(context, m_params);
2213 TestParams m_params;
2216 // Resolve image to image.
2218 enum ResolveImageToImageOptions{NO_OPTIONAL_OPERATION, COPY_MS_IMAGE_TO_MS_IMAGE, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE};
2219 class ResolveImageToImage : public CopiesAndBlittingTestInstance
2222 ResolveImageToImage (Context& context,
2224 const ResolveImageToImageOptions options);
2225 virtual tcu::TestStatus iterate (void);
2227 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
2228 void copyMSImageToMSImage (void);
2230 Move<VkImage> m_multisampledImage;
2231 de::MovePtr<Allocation> m_multisampledImageAlloc;
2233 Move<VkImage> m_destination;
2234 de::MovePtr<Allocation> m_destinationImageAlloc;
2236 Move<VkImage> m_multisampledCopyImage;
2237 de::MovePtr<Allocation> m_multisampledCopyImageAlloc;
2239 const ResolveImageToImageOptions m_options;
2241 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src,
2242 tcu::PixelBufferAccess dst,
2246 ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
2247 : CopiesAndBlittingTestInstance (context, params)
2248 , m_options (options)
2250 const VkSampleCountFlagBits rasterizationSamples = m_params.samples;
2252 if (!(context.getDeviceProperties().limits.framebufferColorSampleCounts & rasterizationSamples))
2253 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
2255 const DeviceInterface& vk = context.getDeviceInterface();
2256 const VkDevice vkDevice = context.getDevice();
2257 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2258 Allocator& memAlloc = m_context.getDefaultAllocator();
2260 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
2261 Move<VkRenderPass> renderPass;
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;
2267 Move<VkBuffer> vertexBuffer;
2268 de::MovePtr<Allocation> vertexBufferAlloc;
2270 Move<VkPipelineLayout> pipelineLayout;
2271 Move<VkPipeline> graphicsPipeline;
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))
2287 TCU_THROW(NotSupportedError, "Format not supported");
2290 // Create color image.
2292 VkImageCreateInfo colorImageParams =
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;
2311 m_multisampledImage = createImage(vk, vkDevice, &colorImageParams);
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()));
2319 case COPY_MS_IMAGE_TO_MS_IMAGE:
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()));
2329 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
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()));
2345 // Create destination image.
2347 const VkImageCreateInfo destinationImageParams =
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;
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()));
2372 // Barriers for copying image to buffer
2373 VkImageMemoryBarrier srcImageBarrier =
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;
2393 // Create render pass.
2395 const VkAttachmentDescription attachmentDescriptions[1] =
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;
2410 const VkAttachmentReference colorAttachmentReference =
2412 0u, // deUint32 attachment;
2413 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2416 const VkSubpassDescription subpassDescription =
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;
2430 const VkRenderPassCreateInfo renderPassParams =
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;
2443 renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
2446 // Create pipeline layout
2448 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
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;
2459 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2462 // Create upper half triangle.
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);
2468 vertices.push_back(a);
2469 vertices.push_back(c);
2470 vertices.push_back(b);
2473 // Create vertex buffer.
2475 const VkDeviceSize vertexDataSize = vertices.size() * sizeof(tcu::Vec4);
2476 const VkBufferCreateInfo vertexBufferParams =
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;
2488 vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
2489 vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
2491 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
2493 // Load vertices into vertex buffer.
2494 deMemcpy(vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexDataSize);
2495 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexDataSize);
2499 Move<VkFramebuffer> framebuffer;
2500 Move<VkImageView> sourceAttachmentView;
2501 //const VkExtent3D extent3D = getExtent3D(m_params.src.image); TODO
2503 // Create color attachment view.
2505 const VkImageViewCreateInfo colorAttachmentViewParams =
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;
2516 sourceAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
2519 // Create framebuffer
2521 const VkImageView attachments[1] =
2523 *sourceAttachmentView,
2526 const VkFramebufferCreateInfo framebufferParams =
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;
2539 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
2544 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
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;
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;
2566 const VkVertexInputBindingDescription vertexInputBindingDescription =
2568 0u, // deUint32 binding;
2569 sizeof(tcu::Vec4), // deUint32 stride;
2570 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
2573 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[1] =
2576 0u, // deUint32 location;
2577 0u, // deUint32 binding;
2578 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2579 0u // deUint32 offset;
2583 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
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;
2594 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
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;
2603 const VkViewport viewport =
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;
2613 const VkRect2D scissor =
2615 { 0, 0 }, // VkOffset2D offset;
2616 { m_params.src.image.extent.width, m_params.src.image.extent.height } // VkExtent2D extent;
2619 const VkPipelineViewportStateCreateInfo viewportStateParams =
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;
2630 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
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;
2647 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
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;
2660 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
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;
2675 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
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];
2687 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
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;
2710 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
2713 // Create command buffer
2715 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
2723 const VkClearValue clearValues[1] =
2725 makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
2728 const VkRenderPassBeginInfo renderPassBeginInfo =
2730 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2731 DE_NULL, // const void* pNext;
2732 *renderPass, // VkRenderPass renderPass;
2733 *framebuffer, // VkFramebuffer framebuffer;
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;
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);
2746 const VkDeviceSize vertexBufferOffset = 0u;
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);
2752 vk.cmdEndRenderPass(*m_cmdBuffer);
2753 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2758 const VkQueue queue = m_context.getUniversalQueue();
2759 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2764 tcu::TestStatus ResolveImageToImage::iterate (void)
2766 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2767 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
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);
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));
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();
2787 case COPY_MS_IMAGE_TO_MS_IMAGE:
2788 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2789 copyMSImageToMSImage();
2795 const DeviceInterface& vk = m_context.getDeviceInterface();
2796 const VkDevice vkDevice = m_context.getDevice();
2797 const VkQueue queue = m_context.getUniversalQueue();
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);
2803 const VkImageMemoryBarrier imageBarriers[] =
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;
2824 // destination image
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_UNDEFINED, // 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;
2845 const VkImageMemoryBarrier postImageBarrier =
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;
2865 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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);
2880 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
2882 return checkTestResult(resultTextureLevel->getAccess());
2885 tcu::TestStatus ResolveImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
2887 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
2888 const float fuzzyThreshold = 0.01f;
2890 for (int arrayLayerNdx = 0; arrayLayerNdx < (int)getArraySize(m_params.dst.image); ++arrayLayerNdx)
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");
2898 return tcu::TestStatus::pass("CopiesAndBlitting test");
2901 void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
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;
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);
2914 tcu::copy(dstSubRegion, srcSubRegion);
2917 void ResolveImageToImage::copyMSImageToMSImage (void)
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;
2925 for (deUint32 layerNdx = 0; layerNdx < getArraySize(m_params.dst.image); ++layerNdx)
2927 const VkImageSubresourceLayers sourceSubresourceLayers =
2929 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2930 0u, // uint32_t mipLevel;
2931 0u, // uint32_t baseArrayLayer;
2932 1u // uint32_t layerCount;
2935 const VkImageSubresourceLayers destinationSubresourceLayers =
2937 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;//getAspectFlags(dstTcuFormat)
2938 0u, // uint32_t mipLevel;
2939 layerNdx, // uint32_t baseArrayLayer;
2940 1u // uint32_t layerCount;
2943 const VkImageCopy imageCopy =
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;
2951 imageCopies.push_back(imageCopy);
2954 const VkImageMemoryBarrier imageBarriers[] =
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;
2975 // destination image
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;
2996 const VkImageMemoryBarrier postImageBarriers =
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;
3017 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
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,
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));
3031 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
3033 m_multisampledImage = m_multisampledCopyImage;
3036 class ResolveImageToImageTestCase : public vkt::TestCase
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)
3046 , m_options (options)
3048 virtual void initPrograms (SourceCollections& programCollection) const;
3050 virtual TestInstance* createInstance (Context& context) const
3052 return new ResolveImageToImage(context, m_params, m_options);
3055 TestParams m_params;
3056 const ResolveImageToImageOptions m_options;
3059 void ResolveImageToImageTestCase::initPrograms (SourceCollections& programCollection) const
3061 programCollection.glslSources.add("vert") << glu::VertexSource(
3063 "layout (location = 0) in highp vec4 a_position;\n"
3066 " gl_Position = a_position;\n"
3070 programCollection.glslSources.add("frag") << glu::FragmentSource(
3072 "layout (location = 0) out highp vec4 o_color;\n"
3075 " o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
3079 std::string getSampleCountCaseName (VkSampleCountFlagBits sampleFlag)
3081 return de::toLower(de::toString(getSampleCountFlagsStr(sampleFlag)).substr(16));
3084 std::string getFormatCaseName (VkFormat format)
3086 return de::toLower(de::toString(getFormatStr(format)).substr(10));
3089 void addCopyImageTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3090 tcu::TestContext& testCtx,
3093 const VkFormat compatibleFormats8Bit[] =
3095 VK_FORMAT_R4G4_UNORM_PACK8,
3098 VK_FORMAT_R8_USCALED,
3099 VK_FORMAT_R8_SSCALED,
3106 const VkFormat compatibleFormats16Bit[] =
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,
3128 VK_FORMAT_R16_SFLOAT,
3132 const VkFormat compatibleFormats24Bit[] =
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,
3151 const VkFormat compatibleFormats32Bit[] =
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,
3195 VK_FORMAT_R32_SFLOAT,
3199 const VkFormat compatibleFormats48Bit[] =
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,
3211 const VkFormat compatibleFormats64Bit[] =
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,
3225 VK_FORMAT_R64_SFLOAT,
3229 const VkFormat compatibleFormats96Bit[] =
3231 VK_FORMAT_R32G32B32_UINT,
3232 VK_FORMAT_R32G32B32_SINT,
3233 VK_FORMAT_R32G32B32_SFLOAT,
3237 const VkFormat compatibleFormats128Bit[] =
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,
3248 const VkFormat compatibleFormats192Bit[] =
3250 VK_FORMAT_R64G64B64_UINT,
3251 VK_FORMAT_R64G64B64_SINT,
3252 VK_FORMAT_R64G64B64_SFLOAT,
3256 const VkFormat compatibleFormats256Bit[] =
3258 VK_FORMAT_R64G64B64A64_UINT,
3259 VK_FORMAT_R64G64B64A64_SINT,
3260 VK_FORMAT_R64G64B64A64_SFLOAT,
3265 const VkFormat* colorImageFormatsToTest[] =
3267 compatibleFormats8Bit,
3268 compatibleFormats16Bit,
3269 compatibleFormats24Bit,
3270 compatibleFormats32Bit,
3271 compatibleFormats48Bit,
3272 compatibleFormats64Bit,
3273 compatibleFormats96Bit,
3274 compatibleFormats128Bit,
3275 compatibleFormats192Bit,
3276 compatibleFormats256Bit,
3278 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3280 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3282 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex];
3283 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3285 params.src.image.format = compatibleFormats[srcFormatIndex];
3286 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3288 params.dst.image.format = compatibleFormats[dstFormatIndex];
3290 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
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;
3298 testCaseGroup->addChild(new CopyImageToImageTestCase(testCtx, testName.str(), description.str(), params));
3304 void addBlittingTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3305 tcu::TestContext& testCtx,
3308 // Test Image formats.
3309 const VkFormat compatibleFormatsUInts[] =
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,
3321 VK_FORMAT_R16G16_UINT,
3322 VK_FORMAT_R16G16B16_UINT,
3323 VK_FORMAT_R16G16B16A16_UINT,
3325 VK_FORMAT_R32G32_UINT,
3326 VK_FORMAT_R32G32B32_UINT,
3327 VK_FORMAT_R32G32B32A32_UINT,
3329 VK_FORMAT_R64G64_UINT,
3330 VK_FORMAT_R64G64B64_UINT,
3331 VK_FORMAT_R64G64B64A64_UINT,
3335 const VkFormat compatibleFormatsSInts[] =
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,
3347 VK_FORMAT_R16G16_SINT,
3348 VK_FORMAT_R16G16B16_SINT,
3349 VK_FORMAT_R16G16B16A16_SINT,
3351 VK_FORMAT_R32G32_SINT,
3352 VK_FORMAT_R32G32B32_SINT,
3353 VK_FORMAT_R32G32B32A32_SINT,
3355 VK_FORMAT_R64G64_SINT,
3356 VK_FORMAT_R64G64B64_SINT,
3357 VK_FORMAT_R64G64B64A64_SINT,
3361 const VkFormat compatibleFormatsFloats[] =
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,
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,
3472 const VkFormat compatibleFormatsSrgb[] =
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,
3508 const VkFormat* compatibleFormats;
3509 const bool onlyNearest;
3510 } colorImageFormatsToTest[] =
3512 { compatibleFormatsUInts, true },
3513 { compatibleFormatsSInts, true },
3514 { compatibleFormatsFloats, false },
3515 { compatibleFormatsSrgb, false },
3517 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3519 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
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)
3525 params.src.image.format = compatibleFormats[srcFormatIndex];
3526 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3528 params.dst.image.format = compatibleFormats[dstFormatIndex];
3530 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
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;
3538 params.filter = VK_FILTER_NEAREST;
3539 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_nearest", description.str(), params));
3543 params.filter = VK_FILTER_LINEAR;
3544 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_linear", description.str(), params));
3553 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
3555 de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
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"));
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"));
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"));
3570 de::MovePtr<tcu::TestCaseGroup> resolveImageTests (new tcu::TestCaseGroup(testCtx, "resolve_image", "Resolve image"));
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};
3578 const VkImageSubresourceLayers defaultSourceLayer =
3580 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
3581 0u, // uint32_t mipLevel;
3582 0u, // uint32_t baseArrayLayer;
3583 1u, // uint32_t layerCount;
3586 const VkFormat depthAndStencilFormats[] =
3588 VK_FORMAT_D16_UNORM,
3589 VK_FORMAT_X8_D24_UNORM_PACK32,
3590 VK_FORMAT_D32_SFLOAT,
3592 VK_FORMAT_D16_UNORM_S8_UINT,
3593 VK_FORMAT_D24_UNORM_S8_UINT,
3594 VK_FORMAT_D32_SFLOAT_S8_UINT,
3597 // Copy image to image testcases.
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;
3608 const VkImageCopy testCopy =
3610 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3611 {0, 0, 0}, // VkOffset3D srcOffset;
3612 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3613 {0, 0, 0}, // VkOffset3D dstOffset;
3614 defaultExtent, // VkExtent3D extent;
3617 CopyRegion imageCopy;
3618 imageCopy.imageCopy = testCopy;
3620 params.regions.push_back(imageCopy);
3623 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image", "Whole image", 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;
3636 const VkImageCopy testCopy =
3638 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3639 {0, 0, 0}, // VkOffset3D srcOffset;
3640 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3641 {0, 0, 0}, // VkOffset3D dstOffset;
3642 defaultExtent, // VkExtent3D extent;
3645 CopyRegion imageCopy;
3646 imageCopy.imageCopy = testCopy;
3648 params.regions.push_back(imageCopy);
3651 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image_diff_fromat", "Whole image with different format", 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;
3664 const VkImageCopy testCopy =
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;
3673 CopyRegion imageCopy;
3674 imageCopy.imageCopy = testCopy;
3676 params.regions.push_back(imageCopy);
3679 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "partial_image", "Partial image", 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;
3692 const VkImageSubresourceLayers sourceLayer =
3694 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
3695 0u, // uint32_t mipLevel;
3696 0u, // uint32_t baseArrayLayer;
3697 1u // uint32_t layerCount;
3699 const VkImageCopy testCopy =
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;
3708 CopyRegion imageCopy;
3709 imageCopy.imageCopy = testCopy;
3711 params.regions.push_back(imageCopy);
3714 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "depth", "With depth", 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;
3727 const VkImageSubresourceLayers sourceLayer =
3729 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
3730 0u, // uint32_t mipLevel;
3731 0u, // uint32_t baseArrayLayer;
3732 1u // uint32_t layerCount;
3734 const VkImageCopy testCopy =
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;
3743 CopyRegion imageCopy;
3744 imageCopy.imageCopy = testCopy;
3746 params.regions.push_back(imageCopy);
3749 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "stencil", "With stencil", params));
3753 // Test Color formats.
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;
3761 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3763 const VkImageCopy testCopy =
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;
3772 CopyRegion imageCopy;
3773 imageCopy.imageCopy = testCopy;
3775 params.regions.push_back(imageCopy);
3778 addCopyImageTestsAllFormats(imgToImgAllFormatsTests.get(), testCtx, params);
3781 // Test Depth and Stencil formats.
3783 const std::string description ("Copy image to image with depth/stencil formats ");
3784 const std::string testName ("depth_stencil");
3786 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
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);
3799 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
3800 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
3802 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
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};
3809 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
3811 const VkImageCopy testCopy =
3813 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
3814 srcOffset, // VkOffset3D srcOffset;
3815 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
3816 dstOffset, // VkOffset3D dstOffset;
3817 extent, // VkExtent3D extent;
3820 copyRegion.imageCopy = testCopy;
3821 params.regions.push_back(copyRegion);
3823 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
3825 const VkImageCopy testCopy =
3827 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
3828 srcOffset, // VkOffset3D srcOffset;
3829 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
3830 dstOffset, // VkOffset3D dstOffset;
3831 extent, // VkExtent3D extent;
3834 copyRegion.imageCopy = testCopy;
3835 params.regions.push_back(copyRegion);
3839 imgToImgAllFormatsTests->addChild(new CopyImageToImageTestCase(testCtx, oss.str(), description, params));
3843 imageToImageTests->addChild(imgToImgSimpleTests.release());
3844 imageToImageTests->addChild(imgToImgAllFormatsTests.release());
3846 // Copy image to buffer testcases.
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;
3854 const VkBufferImageCopy bufferImageCopy =
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;
3863 CopyRegion copyRegion;
3864 copyRegion.bufferImageCopy = bufferImageCopy;
3866 params.regions.push_back(copyRegion);
3868 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "whole", "Copy from image to buffer", 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;
3878 const VkBufferImageCopy bufferImageCopy =
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;
3887 CopyRegion copyRegion;
3888 copyRegion.bufferImageCopy = bufferImageCopy;
3890 params.regions.push_back(copyRegion);
3892 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "buffer_offset", "Copy from image to buffer with buffer offset", 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;
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)
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);
3916 const VkBufferImageCopy bufferImageCopy =
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;
3925 region.bufferImageCopy = bufferImageCopy;
3926 params.regions.push_back(region);
3929 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "regions", "Copy from image to buffer with multiple regions", params));
3932 // Copy buffer to image testcases.
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;
3940 const VkBufferImageCopy bufferImageCopy =
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;
3949 CopyRegion copyRegion;
3950 copyRegion.bufferImageCopy = bufferImageCopy;
3952 params.regions.push_back(copyRegion);
3954 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "whole", "Copy from buffer to image", 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;
3965 deUint32 divisor = 1;
3966 for (int offset = 0; (offset + defaultFourthSize / divisor < defaultSize) && (defaultFourthSize > divisor); offset += defaultFourthSize / divisor++)
3968 const VkBufferImageCopy bufferImageCopy =
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;
3977 region.bufferImageCopy = bufferImageCopy;
3978 params.regions.push_back(region);
3981 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "regions", "Copy from buffer to image with multiple regions", 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;
3991 const VkBufferImageCopy bufferImageCopy =
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;
4000 CopyRegion copyRegion;
4001 copyRegion.bufferImageCopy = bufferImageCopy;
4003 params.regions.push_back(copyRegion);
4005 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_offset", "Copy from buffer to image with buffer offset", params));
4008 // Copy buffer to buffer testcases.
4011 params.src.buffer.size = defaultSize;
4012 params.dst.buffer.size = defaultSize;
4014 const VkBufferCopy bufferCopy =
4016 0u, // VkDeviceSize srcOffset;
4017 0u, // VkDeviceSize dstOffset;
4018 defaultSize, // VkDeviceSize size;
4021 CopyRegion copyRegion;
4022 copyRegion.bufferCopy = bufferCopy;
4023 params.regions.push_back(copyRegion);
4025 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
4030 params.src.buffer.size = defaultFourthSize;
4031 params.dst.buffer.size = defaultFourthSize;
4033 const VkBufferCopy bufferCopy =
4035 12u, // VkDeviceSize srcOffset;
4036 4u, // VkDeviceSize dstOffset;
4037 1u, // VkDeviceSize size;
4040 CopyRegion copyRegion;
4041 copyRegion.bufferCopy = bufferCopy;
4042 params.regions.push_back(copyRegion);
4044 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "partial", "Partial", params));
4048 const deUint32 size = 16;
4050 params.src.buffer.size = size;
4051 params.dst.buffer.size = size * (size + 1);
4053 // Copy region with size 1..size
4054 for (unsigned int i = 1; i <= size; i++)
4056 const VkBufferCopy bufferCopy =
4058 0, // VkDeviceSize srcOffset;
4059 i * size, // VkDeviceSize dstOffset;
4060 i, // VkDeviceSize size;
4063 CopyRegion copyRegion;
4064 copyRegion.bufferCopy = bufferCopy;
4065 params.regions.push_back(copyRegion);
4068 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "regions", "Multiple regions", params));
4071 // Blitting testcases.
4073 const std::string description ("Blit without scaling (whole)");
4074 const std::string testName ("whole");
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;
4084 const VkImageBlit imageBlit =
4086 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4089 {defaultSize, defaultSize, 1}
4090 }, // VkOffset3D srcOffsets[2];
4092 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4095 {defaultSize, defaultSize, 1}
4096 } // VkOffset3D dstOffset[2];
4100 region.imageBlit = imageBlit;
4101 params.regions.push_back(region);
4104 // Filter is VK_FILTER_NEAREST.
4106 params.filter = VK_FILTER_NEAREST;
4108 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4109 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4120 // Filter is VK_FILTER_LINEAR.
4122 params.filter = VK_FILTER_LINEAR;
4124 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4125 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4138 const std::string description ("Flipping x and y coordinates (whole)");
4139 const std::string testName ("mirror_xy");
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;
4149 const VkImageBlit imageBlit =
4151 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4154 {defaultSize, defaultSize, 1}
4155 }, // VkOffset3D srcOffsets[2];
4157 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4159 {defaultSize, defaultSize, 1},
4161 } // VkOffset3D dstOffset[2];
4165 region.imageBlit = imageBlit;
4166 params.regions.push_back(region);
4169 // Filter is VK_FILTER_NEAREST.
4171 params.filter = VK_FILTER_NEAREST;
4173 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4174 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4185 // Filter is VK_FILTER_LINEAR.
4187 params.filter = VK_FILTER_LINEAR;
4189 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4190 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4203 const std::string description ("Flipping x coordinates (whole)");
4204 const std::string testName ("mirror_x");
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;
4214 const VkImageBlit imageBlit =
4216 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4219 {defaultSize, defaultSize, 1}
4220 }, // VkOffset3D srcOffsets[2];
4222 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4224 {defaultSize, 0, 0},
4226 } // VkOffset3D dstOffset[2];
4230 region.imageBlit = imageBlit;
4231 params.regions.push_back(region);
4234 // Filter is VK_FILTER_NEAREST.
4236 params.filter = VK_FILTER_NEAREST;
4238 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4239 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4250 // Filter is VK_FILTER_LINEAR.
4252 params.filter = VK_FILTER_LINEAR;
4254 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4255 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4268 const std::string description ("Flipping Y coordinates (whole)");
4269 const std::string testName ("mirror_y");
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;
4279 const VkImageBlit imageBlit =
4281 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4284 {defaultSize, defaultSize, 1}
4285 }, // VkOffset3D srcOffsets[2];
4287 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4289 {0, defaultSize, 1},
4291 } // VkOffset3D dstOffset[2];
4295 region.imageBlit = imageBlit;
4296 params.regions.push_back(region);
4299 // Filter is VK_FILTER_NEAREST.
4301 params.filter = VK_FILTER_NEAREST;
4303 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4304 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4315 // Filter is VK_FILTER_LINEAR.
4317 params.filter = VK_FILTER_LINEAR;
4319 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4320 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4333 const std::string description ("Mirroring subregions in image (no flip ,y flip ,x flip, xy flip)");
4334 const std::string testName ("mirror_subregions");
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;
4345 const VkImageBlit imageBlit =
4347 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4350 {defaultHalfSize, defaultHalfSize, 1}
4351 }, // VkOffset3D srcOffsets[2];
4353 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4356 {defaultHalfSize, defaultHalfSize, 1}
4357 } // VkOffset3D dstOffset[2];
4361 region.imageBlit = imageBlit;
4362 params.regions.push_back(region);
4365 // Flipping y coordinates.
4367 const VkImageBlit imageBlit =
4369 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4371 {defaultHalfSize, 0, 0},
4372 {defaultSize, defaultHalfSize, 1}
4373 }, // VkOffset3D srcOffsets[2];
4375 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4377 {defaultHalfSize, defaultHalfSize, 0},
4379 } // VkOffset3D dstOffset[2];
4383 region.imageBlit = imageBlit;
4384 params.regions.push_back(region);
4387 // Flipping x coordinates.
4389 const VkImageBlit imageBlit =
4391 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4393 {0, defaultHalfSize, 0},
4394 {defaultHalfSize, defaultSize, 1}
4395 }, // VkOffset3D srcOffsets[2];
4397 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4399 {defaultHalfSize, defaultHalfSize, 0},
4401 } // VkOffset3D dstOffset[2];
4405 region.imageBlit = imageBlit;
4406 params.regions.push_back(region);
4409 // Flipping x and y coordinates.
4411 const VkImageBlit imageBlit =
4413 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4415 {defaultHalfSize, defaultHalfSize, 0},
4416 {defaultSize, defaultSize, 1}
4417 }, // VkOffset3D srcOffsets[2];
4419 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4421 {defaultSize, defaultSize, 0},
4422 {defaultHalfSize, defaultHalfSize, 1}
4423 } // VkOffset3D dstOffset[2];
4427 region.imageBlit = imageBlit;
4428 params.regions.push_back(region);
4431 // Filter is VK_FILTER_NEAREST.
4433 params.filter = VK_FILTER_NEAREST;
4435 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4436 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4447 // Filter is VK_FILTER_LINEAR.
4449 params.filter = VK_FILTER_LINEAR;
4451 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4452 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4465 const std::string description ("Blit with scaling (whole, src extent bigger)");
4466 const std::string testName ("scaling_whole1");
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;
4476 const VkImageBlit imageBlit =
4478 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4481 {defaultSize, defaultSize, 1}
4482 }, // VkOffset3D srcOffsets[2];
4484 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4487 {defaultHalfSize, defaultHalfSize, 1}
4488 } // VkOffset3D dstOffset[2];
4492 region.imageBlit = imageBlit;
4493 params.regions.push_back(region);
4496 // Filter is VK_FILTER_NEAREST.
4498 params.filter = VK_FILTER_NEAREST;
4500 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4501 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4512 // Filter is VK_FILTER_LINEAR.
4514 params.filter = VK_FILTER_LINEAR;
4516 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4517 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4530 const std::string description ("Blit with scaling (whole, dst extent bigger)");
4531 const std::string testName ("scaling_whole2");
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;
4541 const VkImageBlit imageBlit =
4543 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4546 {defaultHalfSize, defaultHalfSize, 1}
4547 }, // VkOffset3D srcOffsets[2];
4549 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4552 {defaultSize, defaultSize, 1}
4553 } // VkOffset3D dstOffset[2];
4557 region.imageBlit = imageBlit;
4558 params.regions.push_back(region);
4561 // Filter is VK_FILTER_NEAREST.
4563 params.filter = VK_FILTER_NEAREST;
4565 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4566 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4577 // Filter is VK_FILTER_LINEAR.
4579 params.filter = VK_FILTER_LINEAR;
4581 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4582 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4595 const std::string description ("Blit with scaling and offset (whole, dst extent bigger)");
4596 const std::string testName ("scaling_and_offset");
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;
4606 const VkImageBlit imageBlit =
4608 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4610 {defaultFourthSize, defaultFourthSize, 0},
4611 {defaultFourthSize*3, defaultFourthSize*3, 1}
4612 }, // VkOffset3D srcOffsets[2];
4614 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4617 {defaultSize, defaultSize, 1}
4618 } // VkOffset3D dstOffset[2];
4622 region.imageBlit = imageBlit;
4623 params.regions.push_back(region);
4626 // Filter is VK_FILTER_NEAREST.
4628 params.filter = VK_FILTER_NEAREST;
4630 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4631 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4642 // Filter is VK_FILTER_LINEAR.
4644 params.filter = VK_FILTER_LINEAR;
4646 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4647 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4660 const std::string description ("Blit without scaling (partial)");
4661 const std::string testName ("without_scaling_partial");
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;
4672 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4674 const VkImageBlit imageBlit =
4676 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4678 {defaultSize - defaultFourthSize - i, defaultSize - defaultFourthSize - i, 0},
4679 {defaultSize - i, defaultSize - i, 1}
4680 }, // VkOffset3D srcOffsets[2];
4682 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4685 {i + defaultFourthSize, i + defaultFourthSize, 1}
4686 } // VkOffset3D dstOffset[2];
4688 region.imageBlit = imageBlit;
4689 params.regions.push_back(region);
4693 // Filter is VK_FILTER_NEAREST.
4695 params.filter = VK_FILTER_NEAREST;
4697 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4698 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
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));
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));
4710 // Filter is VK_FILTER_LINEAR.
4712 params.filter = VK_FILTER_LINEAR;
4714 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4715 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
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));
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));
4728 const std::string description ("Blit with scaling (partial)");
4729 const std::string testName ("scaling_partial");
4731 // Test Color formats.
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;
4740 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4742 const VkImageBlit imageBlit =
4744 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4747 {defaultSize, defaultSize, 1}
4748 }, // VkOffset3D srcOffsets[2];
4750 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4753 {i + defaultFourthSize / j, defaultFourthSize / j, 1}
4754 } // VkOffset3D dstOffset[2];
4756 region.imageBlit = imageBlit;
4757 params.regions.push_back(region);
4759 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4761 const VkImageBlit imageBlit =
4763 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4766 {i + defaultFourthSize, i + defaultFourthSize, 1}
4767 }, // VkOffset3D srcOffsets[2];
4769 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4771 {i, defaultSize / 2, 0},
4772 {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1}
4773 } // VkOffset3D dstOffset[2];
4775 region.imageBlit = imageBlit;
4776 params.regions.push_back(region);
4779 addBlittingTestsAllFormats(blitImgAllFormatsTests.get(), testCtx, params);
4782 // Test Depth and Stencil formats.
4784 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
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);
4797 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
4798 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
4801 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
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};
4808 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4810 const VkImageBlit imageBlit =
4812 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4813 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4814 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4815 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4817 region.imageBlit = imageBlit;
4818 params.regions.push_back(region);
4820 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4822 const VkImageBlit imageBlit =
4824 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4825 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4826 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4827 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4829 region.imageBlit = imageBlit;
4830 params.regions.push_back(region);
4833 for (int i = 0; i < defaultSize; i += defaultFourthSize)
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};
4840 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4842 const VkImageBlit imageBlit =
4844 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4845 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4846 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4847 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4849 region.imageBlit = imageBlit;
4850 params.regions.push_back(region);
4852 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4854 const VkImageBlit imageBlit =
4856 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4857 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4858 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4859 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4861 region.imageBlit = imageBlit;
4862 params.regions.push_back(region);
4866 params.filter = VK_FILTER_NEAREST;
4867 blitImgAllFormatsTests->addChild(new BlittingTestCase(testCtx, oss.str() + "_nearest", description, params));
4871 blittingImageTests->addChild(blitImgSimpleTests.release());
4872 blittingImageTests->addChild(blitImgAllFormatsTests.release());
4874 // Resolve image to image testcases.
4875 const VkSampleCountFlagBits samples[] =
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
4884 const VkExtent3D resolveExtent = {256u, 256u, 1};
4887 const std::string description ("Resolve from image to image");
4888 const std::string testName ("whole");
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;
4899 const VkImageSubresourceLayers sourceLayer =
4901 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4902 0u, // uint32_t mipLevel;
4903 0u, // uint32_t baseArrayLayer;
4904 1u // uint32_t layerCount;
4906 const VkImageResolve testResolve =
4908 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4909 {0, 0, 0}, // VkOffset3D srcOffset;
4910 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4911 {0, 0, 0}, // VkOffset3D dstOffset;
4912 resolveExtent, // VkExtent3D extent;
4915 CopyRegion imageResolve;
4916 imageResolve.imageResolve = testResolve;
4917 params.regions.push_back(imageResolve);
4920 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
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));
4930 const std::string description ("Resolve from image to image");
4931 const std::string testName ("partial");
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;
4942 const VkImageSubresourceLayers sourceLayer =
4944 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4945 0u, // uint32_t mipLevel;
4946 0u, // uint32_t baseArrayLayer;
4947 1u // uint32_t layerCount;
4949 const VkImageResolve testResolve =
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;
4958 CopyRegion imageResolve;
4959 imageResolve.imageResolve = testResolve;
4960 params.regions.push_back(imageResolve);
4963 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
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));
4973 const std::string description ("Resolve from image to image");
4974 const std::string testName ("with_regions");
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;
4985 const VkImageSubresourceLayers sourceLayer =
4987 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4988 0u, // uint32_t mipLevel;
4989 0u, // uint32_t baseArrayLayer;
4990 1u // uint32_t layerCount;
4993 for (int i = 0; i < 256; i += 64)
4995 const VkImageResolve testResolve =
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;
5004 CopyRegion imageResolve;
5005 imageResolve.imageResolve = testResolve;
5006 params.regions.push_back(imageResolve);
5010 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
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));
5020 const std::string description ("Resolve from image to image");
5021 const std::string testName ("whole_copy_before_resolving");
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;
5032 const VkImageSubresourceLayers sourceLayer =
5034 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5035 0u, // uint32_t mipLevel;
5036 0u, // uint32_t baseArrayLayer;
5037 1u // uint32_t layerCount;
5040 const VkImageResolve testResolve =
5042 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5043 {0, 0, 0}, // VkOffset3D srcOffset;
5044 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5045 {0, 0, 0}, // VkOffset3D dstOffset;
5046 defaultExtent, // VkExtent3D extent;
5049 CopyRegion imageResolve;
5050 imageResolve.imageResolve = testResolve;
5051 params.regions.push_back(imageResolve);
5054 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
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));
5064 const std::string description ("Resolve from image to image");
5065 const std::string testName ("whole_array_image");
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;
5076 for (deUint32 layerNdx=0; layerNdx < params.dst.image.extent.depth; ++layerNdx)
5078 const VkImageSubresourceLayers sourceLayer =
5080 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5081 0u, // uint32_t mipLevel;
5082 layerNdx, // uint32_t baseArrayLayer;
5083 1u // uint32_t layerCount;
5086 const VkImageResolve testResolve =
5088 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5089 {0, 0, 0}, // VkOffset3D srcOffset;
5090 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5091 {0, 0, 0}, // VkOffset3D dstOffset;
5092 defaultExtent, // VkExtent3D extent;
5095 CopyRegion imageResolve;
5096 imageResolve.imageResolve = testResolve;
5097 params.regions.push_back(imageResolve);
5100 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
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));
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;
5121 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5123 const VkImageSubresourceLayers sourceLayer =
5125 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5126 0u, // uint32_t mipLevel;
5127 0u, // uint32_t baseArrayLayer;
5128 1u // uint32_t layerCount;
5131 const VkImageSubresourceLayers destinationLayer =
5133 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5134 0u, // uint32_t mipLevel;
5135 slicesLayersNdx, // uint32_t baseArrayLayer;
5136 1u // uint32_t layerCount;
5139 const VkImageCopy testCopy =
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;
5148 CopyRegion imageCopy;
5149 imageCopy.imageCopy = testCopy;
5151 params3DTo2D.regions.push_back(imageCopy);
5153 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
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;
5168 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5170 const VkImageSubresourceLayers sourceLayer =
5172 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5173 0u, // uint32_t mipLevel;
5174 slicesLayersNdx, // uint32_t baseArrayLayer;
5175 1u // uint32_t layerCount;
5178 const VkImageSubresourceLayers destinationLayer =
5180 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5181 0u, // uint32_t mipLevel;
5182 0u, // uint32_t baseArrayLayer;
5183 1u // uint32_t layerCount;
5186 const VkImageCopy testCopy =
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;
5195 CopyRegion imageCopy;
5196 imageCopy.imageCopy = testCopy;
5198 params2DTo3D.regions.push_back(imageCopy);
5201 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
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;
5217 const VkImageSubresourceLayers sourceLayer =
5219 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5220 0u, // uint32_t mipLevel;
5221 0u, // uint32_t baseArrayLayer;
5222 1u // uint32_t layerCount;
5225 const VkImageSubresourceLayers destinationLayer =
5227 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5228 0u, // uint32_t mipLevel;
5229 0, // uint32_t baseArrayLayer;
5230 slicesLayers // uint32_t layerCount;
5233 const VkImageCopy testCopy =
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;
5242 CopyRegion imageCopy;
5243 imageCopy.imageCopy = testCopy;
5245 params3DTo2D.regions.push_back(imageCopy);
5247 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
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;
5263 const VkImageSubresourceLayers sourceLayer =
5265 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5266 0u, // uint32_t mipLevel;
5267 0u, // uint32_t baseArrayLayer;
5268 slicesLayers // uint32_t layerCount;
5271 const VkImageSubresourceLayers destinationLayer =
5273 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5274 0u, // uint32_t mipLevel;
5275 0u, // uint32_t baseArrayLayer;
5276 1u // uint32_t layerCount;
5279 const VkImageCopy testCopy =
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;
5288 CopyRegion imageCopy;
5289 imageCopy.imageCopy = testCopy;
5291 params2DTo3D.regions.push_back(imageCopy);
5294 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
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;
5309 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5310 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5312 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5314 const VkImageSubresourceLayers sourceLayer =
5316 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5317 0u, // uint32_t mipLevel;
5318 0u, // uint32_t baseArrayLayer;
5319 1u // uint32_t layerCount;
5322 const VkImageSubresourceLayers destinationLayer =
5324 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5325 0u, // uint32_t mipLevel;
5326 slicesLayersNdx, // uint32_t baseArrayLayer;
5327 1u // uint32_t layerCount;
5331 const VkImageCopy testCopy =
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;
5338 (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
5339 (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
5341 } // VkExtent3D extent;
5344 CopyRegion imageCopy;
5345 imageCopy.imageCopy = testCopy;
5346 params3DTo2D.regions.push_back(imageCopy);
5348 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
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;
5363 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5364 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5366 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5368 const VkImageSubresourceLayers sourceLayer =
5370 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5371 0u, // uint32_t mipLevel;
5372 slicesLayersNdx, // uint32_t baseArrayLayer;
5373 1u // uint32_t layerCount;
5376 const VkImageSubresourceLayers destinationLayer =
5378 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5379 0u, // uint32_t mipLevel;
5380 0u, // uint32_t baseArrayLayer;
5381 1u // uint32_t layerCount;
5384 const VkImageCopy testCopy =
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;
5391 defaultHalfExtent.width - regionWidth*slicesLayersNdx,
5392 defaultHalfExtent.height - regionHeight*slicesLayersNdx,
5394 } // VkExtent3D extent;
5397 CopyRegion imageCopy;
5398 imageCopy.imageCopy = testCopy;
5400 params2DTo3D.regions.push_back(imageCopy);
5403 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
5406 imageToImageTests->addChild(imgToImg3dImagesTests.release());
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());
5415 return copiesAndBlittingTests.release();