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,
67 static VkImageAspectFlags getAspectFlags (tcu::TextureFormat format)
69 VkImageAspectFlags aspectFlag = 0;
70 aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
71 aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
74 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
84 VkBufferCopy bufferCopy;
85 VkImageCopy imageCopy;
86 VkBufferImageCopy bufferImageCopy;
87 VkImageBlit imageBlit;
88 VkImageResolve imageResolve;
93 VkImageType imageType;
110 std::vector<CopyRegion> regions;
115 VkSampleCountFlagBits samples;
119 inline deUint32 getArraySize(const ImageParms& parms)
121 return (parms.imageType == VK_IMAGE_TYPE_2D) ? parms.extent.depth : 1u;
124 inline VkExtent3D getExtent3D(const ImageParms& parms)
126 const VkExtent3D extent =
130 (parms.imageType == VK_IMAGE_TYPE_2D) ? 1u : parms.extent.depth
135 class CopiesAndBlittingTestInstance : public vkt::TestInstance
138 CopiesAndBlittingTestInstance (Context& context,
139 TestParams testParams);
140 virtual tcu::TestStatus iterate (void) = 0;
144 FILL_MODE_GRADIENT = 0,
147 FILL_MODE_MULTISAMPLE,
153 const TestParams m_params;
155 Move<VkCommandPool> m_cmdPool;
156 Move<VkCommandBuffer> m_cmdBuffer;
157 Move<VkFence> m_fence;
158 de::MovePtr<tcu::TextureLevel> m_sourceTextureLevel;
159 de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
160 de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
162 VkCommandBufferBeginInfo m_cmdBufferBeginInfo;
164 void generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_GRADIENT);
165 virtual void generateExpectedResult (void);
166 void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
167 void uploadImage (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image, const ImageParms& parms);
168 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
169 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
170 deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
172 return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
175 de::MovePtr<tcu::TextureLevel> readImage (const vk::DeviceInterface& vk,
178 vk::Allocator& allocator,
180 const ImageParms& imageParms);
181 void submitCommandsAndWait (const DeviceInterface& vk,
182 const VkDevice device,
184 const VkCommandBuffer& cmdBuffer);
187 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
188 : vkt::TestInstance (context)
189 , m_params (testParams)
191 const DeviceInterface& vk = context.getDeviceInterface();
192 const VkDevice vkDevice = context.getDevice();
193 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
195 // Create command pool
197 const VkCommandPoolCreateInfo cmdPoolParams =
199 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
200 DE_NULL, // const void* pNext;
201 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,// VkCmdPoolCreateFlags flags;
202 queueFamilyIndex, // deUint32 queueFamilyIndex;
205 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
208 // Create command buffer
210 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
212 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
213 DE_NULL, // const void* pNext;
214 *m_cmdPool, // VkCommandPool commandPool;
215 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
216 1u // deUint32 bufferCount;
219 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
224 const VkFenceCreateInfo fenceParams =
226 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
227 DE_NULL, // const void* pNext;
228 0u // VkFenceCreateFlags flags;
231 m_fence = createFence(vk, vkDevice, &fenceParams);
235 void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
237 if (mode == FILL_MODE_GRADIENT)
239 tcu::fillWithComponentGradients(buffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
243 const tcu::Vec4 redColor (1.0, 0.0, 0.0, 1.0);
244 const tcu::Vec4 greenColor (0.0, 1.0, 0.0, 1.0);
245 const tcu::Vec4 blueColor (0.0, 0.0, 1.0, 1.0);
246 const tcu::Vec4 whiteColor (1.0, 1.0, 1.0, 1.0);
248 for (int z = 0; z < depth; z++)
250 for (int y = 0; y < height; y++)
252 for (int x = 0; x < width; x++)
256 case FILL_MODE_WHITE:
257 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
259 buffer.setPixDepth(1.0f, x, y, z);
260 if (tcu::hasStencilComponent(buffer.getFormat().order))
261 buffer.setPixStencil(255, x, y, z);
264 buffer.setPixel(whiteColor, x, y, z);
267 DE_ASSERT(!tcu::isCombinedDepthStencilType(buffer.getFormat().type)); // combined types cannot be accessed directly
268 buffer.setPixel(redColor, x, y, z);
270 case FILL_MODE_MULTISAMPLE:
271 buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
281 void CopiesAndBlittingTestInstance::uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
283 const DeviceInterface& vk = m_context.getDeviceInterface();
284 const VkDevice vkDevice = m_context.getDevice();
285 const deUint32 bufferSize = calculateSize(bufferAccess);
288 deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
289 flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
292 void CopiesAndBlittingTestInstance::uploadImage (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image, const ImageParms& parms)
294 const DeviceInterface& vk = m_context.getDeviceInterface();
295 const VkDevice vkDevice = m_context.getDevice();
296 const VkQueue queue = m_context.getUniversalQueue();
297 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
298 Allocator& memAlloc = m_context.getDefaultAllocator();
299 Move<VkBuffer> buffer;
300 const deUint32 bufferSize = calculateSize(imageAccess);
301 de::MovePtr<Allocation> bufferAlloc;
302 const deUint32 arraySize = getArraySize(parms);
303 const VkExtent3D imageExtent = getExtent3D(parms);
305 // Create source buffer
307 const VkBufferCreateInfo bufferParams =
309 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
310 DE_NULL, // const void* pNext;
311 0u, // VkBufferCreateFlags flags;
312 bufferSize, // VkDeviceSize size;
313 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
314 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
315 1u, // deUint32 queueFamilyIndexCount;
316 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
319 buffer = createBuffer(vk, vkDevice, &bufferParams);
320 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
321 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
324 // Barriers for copying buffer to image
325 const VkBufferMemoryBarrier preBufferBarrier =
327 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
328 DE_NULL, // const void* pNext;
329 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
330 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
331 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
332 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
333 *buffer, // VkBuffer buffer;
334 0u, // VkDeviceSize offset;
335 bufferSize // VkDeviceSize size;
338 const VkImageAspectFlags aspect = getAspectFlags(imageAccess.getFormat());
339 const VkImageMemoryBarrier preImageBarrier =
341 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
342 DE_NULL, // const void* pNext;
343 0u, // VkAccessFlags srcAccessMask;
344 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
345 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
346 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
347 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
348 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
349 image, // VkImage image;
350 { // VkImageSubresourceRange subresourceRange;
351 aspect, // VkImageAspectFlags aspect;
352 0u, // deUint32 baseMipLevel;
353 1u, // deUint32 mipLevels;
354 0u, // deUint32 baseArraySlice;
355 arraySize, // deUint32 arraySize;
359 const VkImageMemoryBarrier postImageBarrier =
361 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
362 DE_NULL, // const void* pNext;
363 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
364 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
365 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
366 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
367 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
368 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
369 image, // VkImage image;
370 { // VkImageSubresourceRange subresourceRange;
371 aspect, // VkImageAspectFlags aspect;
372 0u, // deUint32 baseMipLevel;
373 1u, // deUint32 mipLevels;
374 0u, // deUint32 baseArraySlice;
375 arraySize, // deUint32 arraySize;
379 const deUint32 regionCount = tcu::isCombinedDepthStencilType(imageAccess.getFormat().type) ? 2u : 1u;
380 const VkImageAspectFlags firstRegionAspect = aspect & VK_IMAGE_ASPECT_DEPTH_BIT ? VkImageAspectFlags(VK_IMAGE_ASPECT_DEPTH_BIT) : aspect;
381 const VkBufferImageCopy copyRegion[] =
384 0u, // VkDeviceSize bufferOffset;
385 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
386 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
387 { // VkImageSubresourceLayers imageSubresource;
388 firstRegionAspect, // VkImageAspectFlags aspect;
389 0u, // deUint32 mipLevel;
390 0u, // deUint32 baseArrayLayer;
391 arraySize, // deUint32 layerCount;
393 { 0, 0, 0 }, // VkOffset3D imageOffset;
394 imageExtent // VkExtent3D imageExtent;
397 0u, // VkDeviceSize bufferOffset;
398 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
399 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
400 { // VkImageSubresourceLayers imageSubresource;
401 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspect;
402 0u, // deUint32 mipLevel;
403 0u, // deUint32 baseArrayLayer;
404 arraySize, // deUint32 layerCount;
406 { 0, 0, 0 }, // VkOffset3D imageOffset;
407 imageExtent // VkExtent3D imageExtent;
412 deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
413 flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
415 // Copy buffer to image
416 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
418 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
419 DE_NULL, // const void* pNext;
420 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
421 (const VkCommandBufferInheritanceInfo*)DE_NULL,
424 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
425 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);
426 vk.cmdCopyBufferToImage(*m_cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, regionCount, copyRegion);
427 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);
428 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
430 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
433 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult (tcu::ConstPixelBufferAccess result)
435 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
437 if (isFloatFormat(mapTextureFormat(result.getFormat())))
439 const tcu::Vec4 threshold (0.0f);
440 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
441 return tcu::TestStatus::fail("CopiesAndBlitting test");
445 const tcu::UVec4 threshold (0u);
446 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
447 return tcu::TestStatus::fail("CopiesAndBlitting test");
450 return tcu::TestStatus::pass("CopiesAndBlitting test");
453 void CopiesAndBlittingTestInstance::generateExpectedResult (void)
455 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
456 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
458 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
459 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
461 for (deUint32 i = 0; i < m_params.regions.size(); i++)
462 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
465 class CopiesAndBlittingTestCase : public vkt::TestCase
468 CopiesAndBlittingTestCase (tcu::TestContext& testCtx,
469 const std::string& name,
470 const std::string& description)
471 : vkt::TestCase (testCtx, name, description)
474 virtual TestInstance* createInstance (Context& context) const = 0;
477 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (const vk::DeviceInterface& vk,
480 vk::Allocator& allocator,
482 const ImageParms& imageParms)
484 Move<VkBuffer> buffer;
485 de::MovePtr<Allocation> bufferAlloc;
486 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
487 const tcu::TextureFormat tcuFormat = mapVkFormat(imageParms.format);
488 const VkDeviceSize pixelDataSize = imageParms.extent.width * imageParms.extent.height * imageParms.extent.depth * tcu::getPixelSize(tcuFormat);
489 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(tcuFormat,imageParms.extent.width, imageParms.extent.height, imageParms.extent.depth));
491 // Create destination buffer
493 const VkBufferCreateInfo bufferParams =
495 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
496 DE_NULL, // const void* pNext;
497 0u, // VkBufferCreateFlags flags;
498 pixelDataSize, // VkDeviceSize size;
499 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
500 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
501 1u, // deUint32 queueFamilyIndexCount;
502 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
505 buffer = createBuffer(vk, device, &bufferParams);
506 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
507 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
509 deMemset(bufferAlloc->getHostPtr(), 0, static_cast<size_t>(pixelDataSize));
510 flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
513 // Barriers for copying image to buffer
514 const VkImageAspectFlags aspect = getAspectFlags(tcuFormat);
515 const VkImageMemoryBarrier imageBarrier =
517 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
518 DE_NULL, // const void* pNext;
519 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
520 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
521 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
522 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
523 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
524 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
525 image, // VkImage image;
526 { // VkImageSubresourceRange subresourceRange;
527 aspect, // VkImageAspectFlags aspectMask;
528 0u, // deUint32 baseMipLevel;
529 1u, // deUint32 mipLevels;
530 0u, // deUint32 baseArraySlice;
531 getArraySize(imageParms)// deUint32 arraySize;
535 const VkBufferMemoryBarrier bufferBarrier =
537 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
538 DE_NULL, // const void* pNext;
539 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
540 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
541 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
542 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
543 *buffer, // VkBuffer buffer;
544 0u, // VkDeviceSize offset;
545 pixelDataSize // VkDeviceSize size;
548 // Copy image to buffer
549 const deUint32 regionCount = tcu::isCombinedDepthStencilType(tcuFormat.type) ? 2u : 1u;
550 const VkImageAspectFlags firstRegionAspect = aspect & VK_IMAGE_ASPECT_DEPTH_BIT ? VkImageAspectFlags(VK_IMAGE_ASPECT_DEPTH_BIT) : aspect;
551 const VkBufferImageCopy copyRegion[] =
554 0u, // VkDeviceSize bufferOffset;
555 (deUint32)imageParms.extent.width, // deUint32 bufferRowLength;
556 (deUint32)imageParms.extent.height, // deUint32 bufferImageHeight;
557 { // VkImageSubresourceLayers imageSubresource;
558 firstRegionAspect, // VkImageAspectFlags aspect;
559 0u, // deUint32 mipLevel;
560 0u, // deUint32 baseArrayLayer;
561 getArraySize(imageParms), // deUint32 layerCount;
563 { 0, 0, 0 }, // VkOffset3D imageOffset;
564 getExtent3D(imageParms) // VkExtent3D imageExtent;
567 0u, // VkDeviceSize bufferOffset;
568 (deUint32)imageParms.extent.width, // deUint32 bufferRowLength;
569 (deUint32)imageParms.extent.height, // deUint32 bufferImageHeight;
570 { // VkImageSubresourceLayers imageSubresource;
571 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspect;
572 0u, // deUint32 mipLevel;
573 0u, // deUint32 baseArrayLayer;
574 getArraySize(imageParms), // deUint32 layerCount;
576 { 0, 0, 0 }, // VkOffset3D imageOffset;
577 getExtent3D(imageParms) // VkExtent3D imageExtent;
581 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
583 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
584 DE_NULL, // const void* pNext;
585 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
586 (const VkCommandBufferInheritanceInfo*)DE_NULL,
589 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
590 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);
591 vk.cmdCopyImageToBuffer(*m_cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, regionCount, copyRegion);
592 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);
593 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
595 submitCommandsAndWait (vk, device, queue, *m_cmdBuffer);
598 invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
599 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
604 void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
606 const VkSubmitInfo submitInfo =
608 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
609 DE_NULL, // const void* pNext;
610 0u, // deUint32 waitSemaphoreCount;
611 DE_NULL, // const VkSemaphore* pWaitSemaphores;
612 (const VkPipelineStageFlags*)DE_NULL,
613 1u, // deUint32 commandBufferCount;
614 &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
615 0u, // deUint32 signalSemaphoreCount;
616 DE_NULL // const VkSemaphore* pSignalSemaphores;
619 VK_CHECK(vk.resetFences(device, 1, &m_fence.get()));
620 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
621 VK_CHECK(vk.waitForFences(device, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
624 // Copy from image to image.
626 class CopyImageToImage : public CopiesAndBlittingTestInstance
629 CopyImageToImage (Context& context,
631 virtual tcu::TestStatus iterate (void);
633 Move<VkImage> m_source;
634 de::MovePtr<Allocation> m_sourceImageAlloc;
635 Move<VkImage> m_destination;
636 de::MovePtr<Allocation> m_destinationImageAlloc;
638 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
641 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
642 : CopiesAndBlittingTestInstance(context, params)
644 const DeviceInterface& vk = context.getDeviceInterface();
645 const VkDevice vkDevice = context.getDevice();
646 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
647 Allocator& memAlloc = context.getDefaultAllocator();
649 if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
650 (m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
652 if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1") == context.getDeviceExtensions().end())
653 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
656 VkImageFormatProperties properties;
657 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
658 m_params.src.image.format,
659 m_params.src.image.imageType,
660 VK_IMAGE_TILING_OPTIMAL,
661 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
663 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
664 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
665 m_params.dst.image.format,
666 m_params.dst.image.imageType,
667 VK_IMAGE_TILING_OPTIMAL,
668 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
670 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
672 TCU_THROW(NotSupportedError, "Format not supported");
675 // Create source image
677 const VkImageCreateInfo sourceImageParams =
679 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
680 DE_NULL, // const void* pNext;
681 0u, // VkImageCreateFlags flags;
682 m_params.src.image.imageType, // VkImageType imageType;
683 m_params.src.image.format, // VkFormat format;
684 getExtent3D(m_params.src.image), // VkExtent3D extent;
685 1u, // deUint32 mipLevels;
686 getArraySize(m_params.src.image), // deUint32 arraySize;
687 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
688 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
689 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
690 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
691 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
692 1u, // deUint32 queueFamilyCount;
693 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
694 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
697 m_source = createImage(vk, vkDevice, &sourceImageParams);
698 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
699 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
702 // Create destination image
704 const VkImageCreateInfo destinationImageParams =
706 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
707 DE_NULL, // const void* pNext;
708 0u, // VkImageCreateFlags flags;
709 m_params.dst.image.imageType, // VkImageType imageType;
710 m_params.dst.image.format, // VkFormat format;
711 getExtent3D(m_params.dst.image), // VkExtent3D extent;
712 1u, // deUint32 mipLevels;
713 getArraySize(m_params.dst.image), // deUint32 arraySize;
714 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
715 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
716 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
717 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
718 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
719 1u, // deUint32 queueFamilyCount;
720 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
721 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
724 m_destination = createImage(vk, vkDevice, &destinationImageParams);
725 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
726 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
730 tcu::TestStatus CopyImageToImage::iterate (void)
732 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
733 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
734 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
735 (int)m_params.src.image.extent.width,
736 (int)m_params.src.image.extent.height,
737 (int)m_params.src.image.extent.depth));
738 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_WHITE);
739 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
740 (int)m_params.dst.image.extent.width,
741 (int)m_params.dst.image.extent.height,
742 (int)m_params.dst.image.extent.depth));
743 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);
744 generateExpectedResult();
746 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
747 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
749 const DeviceInterface& vk = m_context.getDeviceInterface();
750 const VkDevice vkDevice = m_context.getDevice();
751 const VkQueue queue = m_context.getUniversalQueue();
752 Allocator& memAlloc = m_context.getDefaultAllocator();
754 std::vector<VkImageCopy> imageCopies;
755 for (deUint32 i = 0; i < m_params.regions.size(); i++)
756 imageCopies.push_back(m_params.regions[i].imageCopy);
758 const VkImageMemoryBarrier imageBarriers[] =
762 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
763 DE_NULL, // const void* pNext;
764 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
765 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
766 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
767 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
768 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
769 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
770 m_source.get(), // VkImage image;
771 { // VkImageSubresourceRange subresourceRange;
772 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
773 0u, // deUint32 baseMipLevel;
774 1u, // deUint32 mipLevels;
775 0u, // deUint32 baseArraySlice;
776 getArraySize(m_params.src.image)// deUint32 arraySize;
781 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
782 DE_NULL, // const void* pNext;
783 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
784 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
785 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
786 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
787 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
788 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
789 m_destination.get(), // VkImage image;
790 { // VkImageSubresourceRange subresourceRange;
791 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
792 0u, // deUint32 baseMipLevel;
793 1u, // deUint32 mipLevels;
794 0u, // deUint32 baseArraySlice;
795 getArraySize(m_params.dst.image)// deUint32 arraySize;
800 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
802 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
803 DE_NULL, // const void* pNext;
804 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
805 (const VkCommandBufferInheritanceInfo*)DE_NULL,
808 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
809 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);
810 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());
811 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
813 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
815 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
817 return checkTestResult(resultTextureLevel->getAccess());
820 void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
822 VkOffset3D srcOffset = region.imageCopy.srcOffset;
823 VkOffset3D dstOffset = region.imageCopy.dstOffset;
824 VkExtent3D extent = region.imageCopy.extent;
826 if (m_params.src.image.imageType == VK_IMAGE_TYPE_3D && m_params.dst.image.imageType == VK_IMAGE_TYPE_2D)
827 dstOffset.z = srcOffset.z;
828 if (m_params.src.image.imageType == VK_IMAGE_TYPE_2D && m_params.dst.image.imageType == VK_IMAGE_TYPE_3D)
830 srcOffset.z = dstOffset.z;
831 extent.depth = std::max(region.imageCopy.extent.depth, region.imageCopy.srcSubresource.layerCount);
835 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
837 DE_ASSERT(src.getFormat() == dst.getFormat());
840 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
841 const tcu::PixelBufferAccess dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
842 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
844 tcu::copy(dstSubRegion, srcSubRegion);
848 if (tcu::hasStencilComponent(src.getFormat().order))
850 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
851 const tcu::PixelBufferAccess dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
852 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
854 tcu::copy(dstSubRegion, srcSubRegion);
859 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
860 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
861 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
862 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
864 tcu::copy(dstSubRegion, srcSubRegion);
868 class CopyImageToImageTestCase : public vkt::TestCase
871 CopyImageToImageTestCase (tcu::TestContext& testCtx,
872 const std::string& name,
873 const std::string& description,
874 const TestParams params)
875 : vkt::TestCase (testCtx, name, description)
879 virtual TestInstance* createInstance (Context& context) const
881 return new CopyImageToImage(context, m_params);
887 // Copy from buffer to buffer.
889 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
892 CopyBufferToBuffer (Context& context, TestParams params);
893 virtual tcu::TestStatus iterate (void);
895 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
896 Move<VkBuffer> m_source;
897 de::MovePtr<Allocation> m_sourceBufferAlloc;
898 Move<VkBuffer> m_destination;
899 de::MovePtr<Allocation> m_destinationBufferAlloc;
902 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
903 : CopiesAndBlittingTestInstance (context, params)
905 const DeviceInterface& vk = context.getDeviceInterface();
906 const VkDevice vkDevice = context.getDevice();
907 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
908 Allocator& memAlloc = context.getDefaultAllocator();
910 // Create source buffer
912 const VkBufferCreateInfo sourceBufferParams =
914 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
915 DE_NULL, // const void* pNext;
916 0u, // VkBufferCreateFlags flags;
917 m_params.src.buffer.size, // VkDeviceSize size;
918 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
919 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
920 1u, // deUint32 queueFamilyIndexCount;
921 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
924 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
925 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
926 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
929 // Create destination buffer
931 const VkBufferCreateInfo destinationBufferParams =
933 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
934 DE_NULL, // const void* pNext;
935 0u, // VkBufferCreateFlags flags;
936 m_params.dst.buffer.size, // VkDeviceSize size;
937 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
938 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
939 1u, // deUint32 queueFamilyIndexCount;
940 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
943 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
944 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
945 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
949 tcu::TestStatus CopyBufferToBuffer::iterate (void)
951 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
952 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
953 generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
955 const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
956 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
957 generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
959 generateExpectedResult();
961 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
962 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
964 const DeviceInterface& vk = m_context.getDeviceInterface();
965 const VkDevice vkDevice = m_context.getDevice();
966 const VkQueue queue = m_context.getUniversalQueue();
968 const VkBufferMemoryBarrier srcBufferBarrier =
970 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
971 DE_NULL, // const void* pNext;
972 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
973 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
974 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
975 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
976 *m_source, // VkBuffer buffer;
977 0u, // VkDeviceSize offset;
978 m_params.src.buffer.size // VkDeviceSize size;
981 const VkBufferMemoryBarrier dstBufferBarrier =
983 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
984 DE_NULL, // const void* pNext;
985 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
986 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
987 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
988 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
989 *m_destination, // VkBuffer buffer;
990 0u, // VkDeviceSize offset;
991 m_params.dst.buffer.size // VkDeviceSize size;
994 std::vector<VkBufferCopy> bufferCopies;
995 for (deUint32 i = 0; i < m_params.regions.size(); i++)
996 bufferCopies.push_back(m_params.regions[i].bufferCopy);
998 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1000 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1001 DE_NULL, // const void* pNext;
1002 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1003 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1006 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1007 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);
1008 vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), &bufferCopies[0]);
1009 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);
1010 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1011 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1016 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1017 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
1018 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1020 return checkTestResult(resultLevel->getAccess());
1023 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1025 deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
1026 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
1027 (size_t)region.bufferCopy.size);
1030 class BufferToBufferTestCase : public vkt::TestCase
1033 BufferToBufferTestCase (tcu::TestContext& testCtx,
1034 const std::string& name,
1035 const std::string& description,
1036 const TestParams params)
1037 : vkt::TestCase (testCtx, name, description)
1041 virtual TestInstance* createInstance (Context& context) const
1043 return new CopyBufferToBuffer(context, m_params);
1046 TestParams m_params;
1049 // Copy from image to buffer.
1051 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1054 CopyImageToBuffer (Context& context,
1055 TestParams testParams);
1056 virtual tcu::TestStatus iterate (void);
1058 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1060 tcu::TextureFormat m_textureFormat;
1061 VkDeviceSize m_bufferSize;
1063 Move<VkImage> m_source;
1064 de::MovePtr<Allocation> m_sourceImageAlloc;
1065 Move<VkBuffer> m_destination;
1066 de::MovePtr<Allocation> m_destinationBufferAlloc;
1069 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1070 : CopiesAndBlittingTestInstance(context, testParams)
1071 , m_textureFormat(mapVkFormat(testParams.src.image.format))
1072 , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1074 const DeviceInterface& vk = context.getDeviceInterface();
1075 const VkDevice vkDevice = context.getDevice();
1076 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1077 Allocator& memAlloc = context.getDefaultAllocator();
1079 // Create source image
1081 const VkImageCreateInfo sourceImageParams =
1083 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1084 DE_NULL, // const void* pNext;
1085 0u, // VkImageCreateFlags flags;
1086 m_params.src.image.imageType, // VkImageType imageType;
1087 m_params.src.image.format, // VkFormat format;
1088 getExtent3D(m_params.src.image), // VkExtent3D extent;
1089 1u, // deUint32 mipLevels;
1090 getArraySize(m_params.src.image), // deUint32 arraySize;
1091 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1092 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1093 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1094 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1095 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1096 1u, // deUint32 queueFamilyCount;
1097 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1098 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1101 m_source = createImage(vk, vkDevice, &sourceImageParams);
1102 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1103 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1106 // Create destination buffer
1108 const VkBufferCreateInfo destinationBufferParams =
1110 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1111 DE_NULL, // const void* pNext;
1112 0u, // VkBufferCreateFlags flags;
1113 m_bufferSize, // VkDeviceSize size;
1114 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1115 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1116 1u, // deUint32 queueFamilyIndexCount;
1117 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1120 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1121 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1122 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1126 tcu::TestStatus CopyImageToBuffer::iterate (void)
1128 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1129 m_params.src.image.extent.width,
1130 m_params.src.image.extent.height,
1131 m_params.src.image.extent.depth));
1132 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
1133 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1134 generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1136 generateExpectedResult();
1138 uploadImage(m_sourceTextureLevel->getAccess(), *m_source, m_params.src.image);
1139 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1141 const DeviceInterface& vk = m_context.getDeviceInterface();
1142 const VkDevice vkDevice = m_context.getDevice();
1143 const VkQueue queue = m_context.getUniversalQueue();
1145 // Barriers for copying image to buffer
1146 const VkImageMemoryBarrier imageBarrier =
1148 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1149 DE_NULL, // const void* pNext;
1150 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1151 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1152 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1153 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1154 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1155 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1156 *m_source, // VkImage image;
1157 { // VkImageSubresourceRange subresourceRange;
1158 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1159 0u, // deUint32 baseMipLevel;
1160 1u, // deUint32 mipLevels;
1161 0u, // deUint32 baseArraySlice;
1162 1u // deUint32 arraySize;
1166 const VkBufferMemoryBarrier bufferBarrier =
1168 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1169 DE_NULL, // const void* pNext;
1170 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1171 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1172 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1173 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1174 *m_destination, // VkBuffer buffer;
1175 0u, // VkDeviceSize offset;
1176 m_bufferSize // VkDeviceSize size;
1179 // Copy from image to buffer
1180 std::vector<VkBufferImageCopy> bufferImageCopies;
1181 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1182 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1184 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1186 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1187 DE_NULL, // const void* pNext;
1188 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1189 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1192 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1193 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);
1194 vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), &bufferImageCopies[0]);
1195 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);
1196 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1198 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1201 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1202 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1203 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1205 return checkTestResult(resultLevel->getAccess());
1208 class CopyImageToBufferTestCase : public vkt::TestCase
1211 CopyImageToBufferTestCase (tcu::TestContext& testCtx,
1212 const std::string& name,
1213 const std::string& description,
1214 const TestParams params)
1215 : vkt::TestCase (testCtx, name, description)
1219 virtual TestInstance* createInstance (Context& context) const
1221 return new CopyImageToBuffer(context, m_params);
1224 TestParams m_params;
1227 void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1229 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1231 rowLength = region.bufferImageCopy.imageExtent.width;
1233 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1235 imageHeight = region.bufferImageCopy.imageExtent.height;
1237 const int texelSize = src.getFormat().getPixelSize();
1238 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1239 const VkOffset3D srcOffset = region.bufferImageCopy.imageOffset;
1240 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1242 for (deUint32 z = 0; z < extent.depth; z++)
1244 for (deUint32 y = 0; y < extent.height; y++)
1246 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1247 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1248 region.bufferImageCopy.imageExtent.width, 1, 1);
1249 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1250 tcu::copy(dstSubRegion, srcSubRegion);
1255 // Copy from buffer to image.
1257 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1260 CopyBufferToImage (Context& context,
1261 TestParams testParams);
1262 virtual tcu::TestStatus iterate (void);
1264 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1266 tcu::TextureFormat m_textureFormat;
1267 VkDeviceSize m_bufferSize;
1269 Move<VkBuffer> m_source;
1270 de::MovePtr<Allocation> m_sourceBufferAlloc;
1271 Move<VkImage> m_destination;
1272 de::MovePtr<Allocation> m_destinationImageAlloc;
1275 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1276 : CopiesAndBlittingTestInstance(context, testParams)
1277 , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1278 , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1280 const DeviceInterface& vk = context.getDeviceInterface();
1281 const VkDevice vkDevice = context.getDevice();
1282 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1283 Allocator& memAlloc = context.getDefaultAllocator();
1285 // Create source buffer
1287 const VkBufferCreateInfo sourceBufferParams =
1289 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1290 DE_NULL, // const void* pNext;
1291 0u, // VkBufferCreateFlags flags;
1292 m_bufferSize, // VkDeviceSize size;
1293 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1294 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1295 1u, // deUint32 queueFamilyIndexCount;
1296 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1299 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1300 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1301 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1304 // Create destination image
1306 const VkImageCreateInfo destinationImageParams =
1308 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1309 DE_NULL, // const void* pNext;
1310 0u, // VkImageCreateFlags flags;
1311 m_params.dst.image.imageType, // VkImageType imageType;
1312 m_params.dst.image.format, // VkFormat format;
1313 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1314 1u, // deUint32 mipLevels;
1315 getArraySize(m_params.dst.image), // deUint32 arraySize;
1316 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1317 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1318 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1319 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1320 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1321 1u, // deUint32 queueFamilyCount;
1322 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1323 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1326 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1327 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1328 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1332 tcu::TestStatus CopyBufferToImage::iterate (void)
1334 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1335 generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1336 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1337 m_params.dst.image.extent.width,
1338 m_params.dst.image.extent.height,
1339 m_params.dst.image.extent.depth));
1341 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
1343 generateExpectedResult();
1345 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1346 uploadImage(m_destinationTextureLevel->getAccess(), *m_destination, m_params.dst.image);
1348 const DeviceInterface& vk = m_context.getDeviceInterface();
1349 const VkDevice vkDevice = m_context.getDevice();
1350 const VkQueue queue = m_context.getUniversalQueue();
1351 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
1353 const VkImageMemoryBarrier imageBarrier =
1355 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1356 DE_NULL, // const void* pNext;
1357 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1358 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1359 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1360 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1361 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1362 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1363 *m_destination, // VkImage image;
1364 { // VkImageSubresourceRange subresourceRange;
1365 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1366 0u, // deUint32 baseMipLevel;
1367 1u, // deUint32 mipLevels;
1368 0u, // deUint32 baseArraySlice;
1369 1u // deUint32 arraySize;
1373 // Copy from buffer to image
1374 std::vector<VkBufferImageCopy> bufferImageCopies;
1375 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1376 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1378 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1380 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1381 DE_NULL, // const void* pNext;
1382 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1383 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1386 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1387 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);
1388 vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies.data());
1389 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1391 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1393 de::MovePtr<tcu::TextureLevel> resultLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
1395 return checkTestResult(resultLevel->getAccess());
1398 class CopyBufferToImageTestCase : public vkt::TestCase
1401 CopyBufferToImageTestCase (tcu::TestContext& testCtx,
1402 const std::string& name,
1403 const std::string& description,
1404 const TestParams params)
1405 : vkt::TestCase (testCtx, name, description)
1409 virtual ~CopyBufferToImageTestCase (void) {}
1411 virtual TestInstance* createInstance (Context& context) const
1413 return new CopyBufferToImage(context, m_params);
1416 TestParams m_params;
1419 void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1421 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1423 rowLength = region.bufferImageCopy.imageExtent.width;
1425 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1427 imageHeight = region.bufferImageCopy.imageExtent.height;
1429 const int texelSize = dst.getFormat().getPixelSize();
1430 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1431 const VkOffset3D dstOffset = region.bufferImageCopy.imageOffset;
1432 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1434 for (deUint32 z = 0; z < extent.depth; z++)
1436 for (deUint32 y = 0; y < extent.height; y++)
1438 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1439 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1440 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1441 region.bufferImageCopy.imageExtent.width, 1, 1);
1442 tcu::copy(dstSubRegion, srcSubRegion);
1447 // Copy from image to image with scaling.
1449 class BlittingImages : public CopiesAndBlittingTestInstance
1452 BlittingImages (Context& context,
1454 virtual tcu::TestStatus iterate (void);
1456 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
1457 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1458 virtual void generateExpectedResult (void);
1460 bool checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess&, const tcu::ConstPixelBufferAccess&, const tcu::ConstPixelBufferAccess&);
1461 Move<VkImage> m_source;
1462 de::MovePtr<Allocation> m_sourceImageAlloc;
1463 Move<VkImage> m_destination;
1464 de::MovePtr<Allocation> m_destinationImageAlloc;
1466 de::MovePtr<tcu::TextureLevel> m_unclampedExpectedTextureLevel;
1469 BlittingImages::BlittingImages (Context& context, TestParams params)
1470 : CopiesAndBlittingTestInstance(context, params)
1472 const DeviceInterface& vk = context.getDeviceInterface();
1473 const VkDevice vkDevice = context.getDevice();
1474 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1475 Allocator& memAlloc = context.getDefaultAllocator();
1477 VkImageFormatProperties properties;
1478 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1479 m_params.src.image.format,
1481 VK_IMAGE_TILING_OPTIMAL,
1482 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1484 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
1485 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1486 m_params.dst.image.format,
1488 VK_IMAGE_TILING_OPTIMAL,
1489 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1491 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
1493 TCU_THROW(NotSupportedError, "Format not supported");
1496 VkFormatProperties srcFormatProperties;
1497 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.src.image.format, &srcFormatProperties);
1498 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT))
1500 TCU_THROW(NotSupportedError, "Format feature blit source not supported");
1503 VkFormatProperties dstFormatProperties;
1504 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.dst.image.format, &dstFormatProperties);
1505 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT))
1507 TCU_THROW(NotSupportedError, "Format feature blit destination not supported");
1510 if (m_params.filter == VK_FILTER_LINEAR)
1512 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1513 TCU_THROW(NotSupportedError, "Source format feature sampled image filter linear not supported");
1514 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1515 TCU_THROW(NotSupportedError, "Destination format feature sampled image filter linear not supported");
1518 // Create source image
1520 const VkImageCreateInfo sourceImageParams =
1522 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1523 DE_NULL, // const void* pNext;
1524 0u, // VkImageCreateFlags flags;
1525 m_params.src.image.imageType, // VkImageType imageType;
1526 m_params.src.image.format, // VkFormat format;
1527 getExtent3D(m_params.src.image), // VkExtent3D extent;
1528 1u, // deUint32 mipLevels;
1529 getArraySize(m_params.src.image), // deUint32 arraySize;
1530 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1531 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1532 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1533 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1534 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1535 1u, // deUint32 queueFamilyCount;
1536 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1537 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1540 m_source = createImage(vk, vkDevice, &sourceImageParams);
1541 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1542 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1545 // Create destination image
1547 const VkImageCreateInfo destinationImageParams =
1549 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1550 DE_NULL, // const void* pNext;
1551 0u, // VkImageCreateFlags flags;
1552 m_params.dst.image.imageType, // VkImageType imageType;
1553 m_params.dst.image.format, // VkFormat format;
1554 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1555 1u, // deUint32 mipLevels;
1556 getArraySize(m_params.dst.image), // deUint32 arraySize;
1557 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1558 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1559 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1560 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1561 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1562 1u, // deUint32 queueFamilyCount;
1563 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1564 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1567 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1568 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1569 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1573 tcu::TestStatus BlittingImages::iterate (void)
1575 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
1576 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
1577 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
1578 m_params.src.image.extent.width,
1579 m_params.src.image.extent.height,
1580 m_params.src.image.extent.depth));
1581 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);
1582 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
1583 (int)m_params.dst.image.extent.width,
1584 (int)m_params.dst.image.extent.height,
1585 (int)m_params.dst.image.extent.depth));
1586 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);
1587 generateExpectedResult();
1589 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
1590 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
1592 const DeviceInterface& vk = m_context.getDeviceInterface();
1593 const VkDevice vkDevice = m_context.getDevice();
1594 const VkQueue queue = m_context.getUniversalQueue();
1595 Allocator& memAlloc = m_context.getDefaultAllocator();
1597 std::vector<VkImageBlit> regions;
1598 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1599 regions.push_back(m_params.regions[i].imageBlit);
1601 // Barriers for copying image to buffer
1602 const VkImageMemoryBarrier srcImageBarrier =
1604 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1605 DE_NULL, // const void* pNext;
1606 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1607 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1608 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1609 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1610 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1611 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1612 m_source.get(), // VkImage image;
1613 { // VkImageSubresourceRange subresourceRange;
1614 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
1615 0u, // deUint32 baseMipLevel;
1616 1u, // deUint32 mipLevels;
1617 0u, // deUint32 baseArraySlice;
1618 1u // deUint32 arraySize;
1622 const VkImageMemoryBarrier dstImageBarrier =
1624 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1625 DE_NULL, // const void* pNext;
1626 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1627 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1628 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1629 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1630 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1631 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1632 m_destination.get(), // VkImage image;
1633 { // VkImageSubresourceRange subresourceRange;
1634 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
1635 0u, // deUint32 baseMipLevel;
1636 1u, // deUint32 mipLevels;
1637 0u, // deUint32 baseArraySlice;
1638 1u // deUint32 arraySize;
1642 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1644 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1645 DE_NULL, // const void* pNext;
1646 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1647 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1650 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1651 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);
1652 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);
1653 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);
1654 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1655 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1657 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
1659 return checkTestResult(resultTextureLevel->getAccess());
1662 static float calculateFloatConversionError (int srcBits)
1666 const int clampedBits = de::clamp<int>(srcBits, 0, 32);
1667 const float srcMaxValue = de::max((float)(1ULL<<clampedBits) - 1.0f, 1.0f);
1668 const float error = 1.0f / srcMaxValue;
1670 return de::clamp<float>(error, 0.0f, 1.0f);
1676 tcu::Vec4 getFormatThreshold (const tcu::TextureFormat& format)
1678 tcu::Vec4 threshold(0.01f);
1680 switch (format.type)
1682 case tcu::TextureFormat::HALF_FLOAT:
1683 threshold = tcu::Vec4(0.005f);
1686 case tcu::TextureFormat::FLOAT:
1687 case tcu::TextureFormat::FLOAT64:
1688 threshold = tcu::Vec4(0.001f);
1691 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1692 threshold = tcu::Vec4(0.02f, 0.02f, 0.0625f, 1.0f);
1695 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1696 threshold = tcu::Vec4(0.05f, 0.05f, 0.05f, 1.0f);
1700 const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(format);
1701 threshold = tcu::Vec4(calculateFloatConversionError(bits.x()),
1702 calculateFloatConversionError(bits.y()),
1703 calculateFloatConversionError(bits.z()),
1704 calculateFloatConversionError(bits.w()));
1707 // Return value matching the channel order specified by the format
1708 if (format.order == tcu::TextureFormat::BGR || format.order == tcu::TextureFormat::BGRA)
1709 return threshold.swizzle(2, 1, 0, 3);
1714 bool BlittingImages::checkClampedAndUnclampedResult(const tcu::ConstPixelBufferAccess& result,
1715 const tcu::ConstPixelBufferAccess& clampedExpected,
1716 const tcu::ConstPixelBufferAccess& unclampedExpected)
1718 tcu::TestLog& log (m_context.getTestContext().getLog());
1719 const bool isLinear = m_params.filter == VK_FILTER_LINEAR;
1720 const tcu::TextureFormat srcFormat = m_sourceTextureLevel->getFormat();
1721 const tcu::TextureFormat dstFormat = result.getFormat();
1725 log << tcu::TestLog::Section("ClampedSourceImage", "Region with clamped edges on source image.");
1727 if (isFloatFormat(mapTextureFormat(dstFormat)))
1729 const bool srcIsSRGB = tcu::isSRGB(srcFormat);
1730 const tcu::Vec4 srcMaxDiff = getFormatThreshold(srcFormat) * tcu::Vec4(srcIsSRGB ? 2.0f : 1.0f);
1731 const tcu::Vec4 dstMaxDiff = getFormatThreshold(dstFormat);
1732 const tcu::Vec4 threshold = tcu::max(srcMaxDiff, dstMaxDiff);
1734 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1737 log << tcu::TestLog::EndSection;
1739 if (!isOk && isLinear)
1741 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1742 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1743 log << tcu::TestLog::EndSection;
1748 tcu::UVec4 threshold;
1749 // Calculate threshold depending on channel width of destination format.
1750 const tcu::IVec4 bitDepth = tcu::getTextureFormatBitDepth(dstFormat);
1751 for (deUint32 i = 0; i < 4; ++i)
1752 threshold[i] = de::max( (0x1 << bitDepth[i]) / 256, 1);
1754 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1757 log << tcu::TestLog::EndSection;
1759 if (!isOk && isLinear)
1761 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1762 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1763 log << tcu::TestLog::EndSection;
1769 tcu::TestStatus BlittingImages::checkTestResult (tcu::ConstPixelBufferAccess result)
1771 DE_ASSERT(m_params.filter == VK_FILTER_NEAREST || m_params.filter == VK_FILTER_LINEAR);
1773 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
1775 if (tcu::hasDepthComponent(result.getFormat().order))
1777 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_DEPTH;
1778 const tcu::ConstPixelBufferAccess depthResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1779 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1780 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1782 if (!checkClampedAndUnclampedResult(depthResult, clampedExpected, unclampedExpected))
1784 return tcu::TestStatus::fail("CopiesAndBlitting test");
1788 if (tcu::hasStencilComponent(result.getFormat().order))
1790 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_STENCIL;
1791 const tcu::ConstPixelBufferAccess stencilResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1792 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1793 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1795 if (!checkClampedAndUnclampedResult(stencilResult, clampedExpected, unclampedExpected))
1797 return tcu::TestStatus::fail("CopiesAndBlitting test");
1803 if (!checkClampedAndUnclampedResult(result, m_expectedTextureLevel->getAccess(), m_params.filter == VK_FILTER_LINEAR ? m_unclampedExpectedTextureLevel->getAccess() : tcu::ConstPixelBufferAccess()))
1805 return tcu::TestStatus::fail("CopiesAndBlitting test");
1809 return tcu::TestStatus::pass("CopiesAndBlitting test");
1812 tcu::Vec4 linearToSRGBIfNeeded (const tcu::TextureFormat& format, const tcu::Vec4& color)
1814 return isSRGB(format) ? linearToSRGB(color) : color;
1817 void scaleFromWholeSrcBuffer (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const VkOffset3D regionOffset, const VkOffset3D regionExtent, tcu::Sampler::FilterMode filter)
1819 DE_ASSERT(filter == tcu::Sampler::LINEAR);
1820 DE_ASSERT(dst.getDepth() == 1 && src.getDepth() == 1);
1822 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1823 filter, filter, 0.0f, false);
1825 float sX = (float)regionExtent.x / (float)dst.getWidth();
1826 float sY = (float)regionExtent.y / (float)dst.getHeight();
1828 for (int y = 0; y < dst.getHeight(); y++)
1829 for (int x = 0; x < dst.getWidth(); x++)
1830 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);
1833 void blit (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const tcu::Sampler::FilterMode filter, const MirrorMode mirrorMode)
1835 DE_ASSERT(filter == tcu::Sampler::NEAREST || filter == tcu::Sampler::LINEAR);
1837 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1838 filter, filter, 0.0f, false);
1840 const float sX = (float)src.getWidth() / (float)dst.getWidth();
1841 const float sY = (float)src.getHeight() / (float)dst.getHeight();
1842 const float sZ = (float)src.getDepth() / (float)dst.getDepth();
1844 tcu::Mat2 rotMatrix;
1845 rotMatrix(0,0) = (mirrorMode & MIRROR_MODE_X) ? -1.0f : 1.0f;
1846 rotMatrix(0,1) = 0.0f;
1847 rotMatrix(1,0) = 0.0f;
1848 rotMatrix(1,1) = (mirrorMode & MIRROR_MODE_Y) ? -1.0f : 1.0f;
1850 const int xOffset = (mirrorMode & MIRROR_MODE_X) ? dst.getWidth() - 1 : 0;
1851 const int yOffset = (mirrorMode & MIRROR_MODE_Y) ? dst.getHeight() - 1 : 0;
1853 if (dst.getDepth() == 1 && src.getDepth() == 1)
1855 for (int y = 0; y < dst.getHeight(); ++y)
1856 for (int x = 0; x < dst.getWidth(); ++x)
1858 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1859 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);
1864 for (int z = 0; z < dst.getDepth(); ++z)
1865 for (int y = 0; y < dst.getHeight(); ++y)
1866 for (int x = 0; x < dst.getWidth(); ++x)
1868 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1869 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);
1874 void flipCoordinates (CopyRegion& region, const MirrorMode mirrorMode)
1876 const VkOffset3D dstOffset0 = region.imageBlit.dstOffsets[0];
1877 const VkOffset3D dstOffset1 = region.imageBlit.dstOffsets[1];
1878 const VkOffset3D srcOffset0 = region.imageBlit.srcOffsets[0];
1879 const VkOffset3D srcOffset1 = region.imageBlit.srcOffsets[1];
1881 if (mirrorMode > MIRROR_MODE_NONE && mirrorMode < MIRROR_MODE_LAST)
1884 region.imageBlit.srcOffsets[0].x = std::min(srcOffset0.x, srcOffset1.x);
1885 region.imageBlit.srcOffsets[0].y = std::min(srcOffset0.y, srcOffset1.y);
1887 region.imageBlit.srcOffsets[1].x = std::max(srcOffset0.x, srcOffset1.x);
1888 region.imageBlit.srcOffsets[1].y = std::max(srcOffset0.y, srcOffset1.y);
1891 region.imageBlit.dstOffsets[0].x = std::min(dstOffset0.x, dstOffset1.x);
1892 region.imageBlit.dstOffsets[0].y = std::min(dstOffset0.y, dstOffset1.y);
1894 region.imageBlit.dstOffsets[1].x = std::max(dstOffset0.x, dstOffset1.x);
1895 region.imageBlit.dstOffsets[1].y = std::max(dstOffset0.y, dstOffset1.y);
1899 MirrorMode getMirrorMode(const VkOffset3D x1, const VkOffset3D x2)
1901 if (x1.x >= x2.x && x1.y >= x2.y)
1903 return MIRROR_MODE_XY;
1905 else if (x1.x <= x2.x && x1.y <= x2.y)
1907 return MIRROR_MODE_NONE;
1909 else if (x1.x <= x2.x && x1.y >= x2.y)
1911 return MIRROR_MODE_Y;
1913 else if (x1.x >= x2.x && x1.y <= x2.y)
1915 return MIRROR_MODE_X;
1917 return MIRROR_MODE_LAST;
1920 MirrorMode getMirrorMode(const VkOffset3D s1, const VkOffset3D s2, const VkOffset3D d1, const VkOffset3D d2)
1922 const MirrorMode source = getMirrorMode(s1, s2);
1923 const MirrorMode destination = getMirrorMode(d1, d2);
1925 if (source == destination)
1927 return MIRROR_MODE_NONE;
1929 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_X) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_X) ||
1930 (source == MIRROR_MODE_Y && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_Y && source == MIRROR_MODE_NONE))
1932 return MIRROR_MODE_Y;
1934 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_Y) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_Y) ||
1935 (source == MIRROR_MODE_X && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_X && source == MIRROR_MODE_NONE))
1937 return MIRROR_MODE_X;
1939 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_NONE))
1941 return MIRROR_MODE_XY;
1943 return MIRROR_MODE_LAST;
1946 void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1948 const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
1949 region.imageBlit.srcOffsets[1],
1950 region.imageBlit.dstOffsets[0],
1951 region.imageBlit.dstOffsets[1]);
1953 flipCoordinates(region, mirrorMode);
1955 const VkOffset3D srcOffset = region.imageBlit.srcOffsets[0];
1956 const VkOffset3D srcExtent =
1958 region.imageBlit.srcOffsets[1].x - srcOffset.x,
1959 region.imageBlit.srcOffsets[1].y - srcOffset.y,
1960 region.imageBlit.srcOffsets[1].z - srcOffset.z
1962 const VkOffset3D dstOffset = region.imageBlit.dstOffsets[0];
1963 const VkOffset3D dstExtent =
1965 region.imageBlit.dstOffsets[1].x - dstOffset.x,
1966 region.imageBlit.dstOffsets[1].y - dstOffset.y,
1967 region.imageBlit.dstOffsets[1].z - dstOffset.z
1969 const tcu::Sampler::FilterMode filter = (m_params.filter == VK_FILTER_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
1971 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
1973 DE_ASSERT(src.getFormat() == dst.getFormat());
1975 if (tcu::hasDepthComponent(src.getFormat().order))
1977 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_DEPTH);
1978 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
1979 tcu::scale(dstSubRegion, srcSubRegion, filter);
1981 if (filter == tcu::Sampler::LINEAR)
1983 const tcu::ConstPixelBufferAccess depthSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH);
1984 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
1985 scaleFromWholeSrcBuffer(unclampedSubRegion, depthSrc, srcOffset, srcExtent, filter);
1990 if (tcu::hasStencilComponent(src.getFormat().order))
1992 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_STENCIL);
1993 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
1994 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
1996 if (filter == tcu::Sampler::LINEAR)
1998 const tcu::ConstPixelBufferAccess stencilSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL);
1999 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2000 scaleFromWholeSrcBuffer(unclampedSubRegion, stencilSrc, srcOffset, srcExtent, filter);
2006 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y);
2007 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2008 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2010 if (filter == tcu::Sampler::LINEAR)
2012 const tcu::PixelBufferAccess unclampedSubRegion = tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2013 scaleFromWholeSrcBuffer(unclampedSubRegion, src, srcOffset, srcExtent, filter);
2018 void BlittingImages::generateExpectedResult (void)
2020 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
2021 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
2023 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2024 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
2026 if (m_params.filter == VK_FILTER_LINEAR)
2028 m_unclampedExpectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2029 tcu::copy(m_unclampedExpectedTextureLevel->getAccess(), dst);
2032 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2034 CopyRegion region = m_params.regions[i];
2035 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), region);
2039 class BlittingTestCase : public vkt::TestCase
2042 BlittingTestCase (tcu::TestContext& testCtx,
2043 const std::string& name,
2044 const std::string& description,
2045 const TestParams params)
2046 : vkt::TestCase (testCtx, name, description)
2050 virtual TestInstance* createInstance (Context& context) const
2052 return new BlittingImages(context, m_params);
2055 TestParams m_params;
2058 // Resolve image to image.
2060 enum ResolveImageToImageOptions{NO_OPTIONAL_OPERATION, COPY_MS_IMAGE_TO_MS_IMAGE, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE};
2061 class ResolveImageToImage : public CopiesAndBlittingTestInstance
2064 ResolveImageToImage (Context& context,
2066 const ResolveImageToImageOptions options);
2067 virtual tcu::TestStatus iterate (void);
2069 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
2070 void copyMSImageToMSImage (void);
2072 Move<VkImage> m_multisampledImage;
2073 de::MovePtr<Allocation> m_multisampledImageAlloc;
2075 Move<VkImage> m_destination;
2076 de::MovePtr<Allocation> m_destinationImageAlloc;
2078 Move<VkImage> m_multisampledCopyImage;
2079 de::MovePtr<Allocation> m_multisampledCopyImageAlloc;
2081 const ResolveImageToImageOptions m_options;
2083 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src,
2084 tcu::PixelBufferAccess dst,
2088 ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
2089 : CopiesAndBlittingTestInstance (context, params)
2090 , m_options (options)
2092 const VkSampleCountFlagBits rasterizationSamples = m_params.samples;
2094 if (!(context.getDeviceProperties().limits.framebufferColorSampleCounts & rasterizationSamples))
2095 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
2097 const DeviceInterface& vk = context.getDeviceInterface();
2098 const VkDevice vkDevice = context.getDevice();
2099 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2100 Allocator& memAlloc = m_context.getDefaultAllocator();
2102 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
2103 Move<VkRenderPass> renderPass;
2105 Move<VkShaderModule> vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0);
2106 Move<VkShaderModule> fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0);
2107 std::vector<tcu::Vec4> vertices;
2109 Move<VkBuffer> vertexBuffer;
2110 de::MovePtr<Allocation> vertexBufferAlloc;
2112 Move<VkPipelineLayout> pipelineLayout;
2113 Move<VkPipeline> graphicsPipeline;
2115 VkImageFormatProperties properties;
2116 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2117 m_params.src.image.format,
2118 m_params.src.image.imageType,
2119 VK_IMAGE_TILING_OPTIMAL,
2120 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
2121 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
2122 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2123 m_params.dst.image.format,
2124 m_params.dst.image.imageType,
2125 VK_IMAGE_TILING_OPTIMAL,
2126 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
2127 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
2129 TCU_THROW(NotSupportedError, "Format not supported");
2132 // Create color image.
2134 VkImageCreateInfo colorImageParams =
2136 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2137 DE_NULL, // const void* pNext;
2138 0u, // VkImageCreateFlags flags;
2139 m_params.src.image.imageType, // VkImageType imageType;
2140 m_params.src.image.format, // VkFormat format;
2141 getExtent3D(m_params.src.image), // VkExtent3D extent;
2142 1u, // deUint32 mipLevels;
2143 getArraySize(m_params.src.image), // deUint32 arrayLayers;
2144 rasterizationSamples, // VkSampleCountFlagBits samples;
2145 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2146 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage;
2147 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2148 1u, // deUint32 queueFamilyIndexCount;
2149 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2150 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2153 m_multisampledImage = createImage(vk, vkDevice, &colorImageParams);
2155 // Allocate and bind color image memory.
2156 m_multisampledImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledImage), MemoryRequirement::Any);
2157 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledImage, m_multisampledImageAlloc->getMemory(), m_multisampledImageAlloc->getOffset()));
2161 case COPY_MS_IMAGE_TO_MS_IMAGE:
2163 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2164 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2165 // Allocate and bind color image memory.
2166 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2167 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2171 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2173 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2174 colorImageParams.arrayLayers = getArraySize(m_params.dst.image);
2175 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2176 // Allocate and bind color image memory.
2177 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2178 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2187 // Create destination image.
2189 const VkImageCreateInfo destinationImageParams =
2191 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2192 DE_NULL, // const void* pNext;
2193 0u, // VkImageCreateFlags flags;
2194 m_params.dst.image.imageType, // VkImageType imageType;
2195 m_params.dst.image.format, // VkFormat format;
2196 getExtent3D(m_params.dst.image), // VkExtent3D extent;
2197 1u, // deUint32 mipLevels;
2198 getArraySize(m_params.dst.image), // deUint32 arraySize;
2199 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
2200 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2201 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2202 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
2203 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2204 1u, // deUint32 queueFamilyCount;
2205 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2206 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2209 m_destination = createImage(vk, vkDevice, &destinationImageParams);
2210 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
2211 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
2214 // Barriers for copying image to buffer
2215 VkImageMemoryBarrier srcImageBarrier =
2217 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2218 DE_NULL, // const void* pNext;
2219 0u, // VkAccessFlags srcAccessMask;
2220 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2221 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2222 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2223 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2224 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2225 m_multisampledImage.get(), // VkImage image;
2226 { // VkImageSubresourceRange subresourceRange;
2227 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
2228 0u, // deUint32 baseMipLevel;
2229 1u, // deUint32 mipLevels;
2230 0u, // deUint32 baseArraySlice;
2231 getArraySize(m_params.src.image) // deUint32 arraySize;
2235 // Create render pass.
2237 const VkAttachmentDescription attachmentDescriptions[1] =
2240 0u, // VkAttachmentDescriptionFlags flags;
2241 m_params.src.image.format, // VkFormat format;
2242 rasterizationSamples, // VkSampleCountFlagBits samples;
2243 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
2244 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2245 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
2246 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
2247 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
2248 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
2252 const VkAttachmentReference colorAttachmentReference =
2254 0u, // deUint32 attachment;
2255 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2258 const VkSubpassDescription subpassDescription =
2260 0u, // VkSubpassDescriptionFlags flags;
2261 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2262 0u, // deUint32 inputAttachmentCount;
2263 DE_NULL, // const VkAttachmentReference* pInputAttachments;
2264 1u, // deUint32 colorAttachmentCount;
2265 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
2266 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2267 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
2268 0u, // deUint32 preserveAttachmentCount;
2269 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
2272 const VkRenderPassCreateInfo renderPassParams =
2274 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
2275 DE_NULL, // const void* pNext;
2276 0u, // VkRenderPassCreateFlags flags;
2277 1u, // deUint32 attachmentCount;
2278 attachmentDescriptions, // const VkAttachmentDescription* pAttachments;
2279 1u, // deUint32 subpassCount;
2280 &subpassDescription, // const VkSubpassDescription* pSubpasses;
2281 0u, // deUint32 dependencyCount;
2282 DE_NULL // const VkSubpassDependency* pDependencies;
2285 renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
2288 // Create pipeline layout
2290 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
2292 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
2293 DE_NULL, // const void* pNext;
2294 0u, // VkPipelineLayoutCreateFlags flags;
2295 0u, // deUint32 setLayoutCount;
2296 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
2297 0u, // deUint32 pushConstantRangeCount;
2298 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
2301 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2304 // Create upper half triangle.
2306 const tcu::Vec4 a (-1.0, -1.0, 0.0, 1.0);
2307 const tcu::Vec4 b (1.0, -1.0, 0.0, 1.0);
2308 const tcu::Vec4 c (1.0, 1.0, 0.0, 1.0);
2310 vertices.push_back(a);
2311 vertices.push_back(c);
2312 vertices.push_back(b);
2315 // Create vertex buffer.
2317 const VkDeviceSize vertexDataSize = vertices.size() * sizeof(tcu::Vec4);
2318 const VkBufferCreateInfo vertexBufferParams =
2320 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
2321 DE_NULL, // const void* pNext;
2322 0u, // VkBufferCreateFlags flags;
2323 vertexDataSize, // VkDeviceSize size;
2324 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
2325 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2326 1u, // deUint32 queueFamilyIndexCount;
2327 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
2330 vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
2331 vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
2333 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
2335 // Load vertices into vertex buffer.
2336 deMemcpy(vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexDataSize);
2337 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexDataSize);
2341 Move<VkFramebuffer> framebuffer;
2342 Move<VkImageView> sourceAttachmentView;
2343 //const VkExtent3D extent3D = getExtent3D(m_params.src.image); TODO
2345 // Create color attachment view.
2347 const VkImageViewCreateInfo colorAttachmentViewParams =
2349 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
2350 DE_NULL, // const void* pNext;
2351 0u, // VkImageViewCreateFlags flags;
2352 *m_multisampledImage, // VkImage image;
2353 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
2354 m_params.src.image.format, // VkFormat format;
2355 componentMappingRGBA, // VkComponentMapping components;
2356 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
2358 sourceAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
2361 // Create framebuffer
2363 const VkImageView attachments[1] =
2365 *sourceAttachmentView,
2368 const VkFramebufferCreateInfo framebufferParams =
2370 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
2371 DE_NULL, // const void* pNext;
2372 0u, // VkFramebufferCreateFlags flags;
2373 *renderPass, // VkRenderPass renderPass;
2374 1u, // deUint32 attachmentCount;
2375 attachments, // const VkImageView* pAttachments;
2376 m_params.src.image.extent.width, // deUint32 width;
2377 m_params.src.image.extent.height, // deUint32 height;
2378 1u // deUint32 layers;
2381 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
2386 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
2389 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2390 DE_NULL, // const void* pNext;
2391 0u, // VkPipelineShaderStageCreateFlags flags;
2392 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
2393 *vertexShaderModule, // VkShaderModule module;
2394 "main", // const char* pName;
2395 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2398 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2399 DE_NULL, // const void* pNext;
2400 0u, // VkPipelineShaderStageCreateFlags flags;
2401 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
2402 *fragmentShaderModule, // VkShaderModule module;
2403 "main", // const char* pName;
2404 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2408 const VkVertexInputBindingDescription vertexInputBindingDescription =
2410 0u, // deUint32 binding;
2411 sizeof(tcu::Vec4), // deUint32 stride;
2412 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
2415 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[1] =
2418 0u, // deUint32 location;
2419 0u, // deUint32 binding;
2420 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2421 0u // deUint32 offset;
2425 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
2427 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
2428 DE_NULL, // const void* pNext;
2429 0u, // VkPipelineVertexInputStateCreateFlags flags;
2430 1u, // deUint32 vertexBindingDescriptionCount;
2431 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
2432 1u, // deUint32 vertexAttributeDescriptionCount;
2433 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
2436 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
2438 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
2439 DE_NULL, // const void* pNext;
2440 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
2441 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
2442 false // VkBool32 primitiveRestartEnable;
2445 const VkViewport viewport =
2449 (float)m_params.src.image.extent.width, // float width;
2450 (float)m_params.src.image.extent.height,// float height;
2451 0.0f, // float minDepth;
2452 1.0f // float maxDepth;
2455 const VkRect2D scissor =
2457 { 0, 0 }, // VkOffset2D offset;
2458 { m_params.src.image.extent.width, m_params.src.image.extent.height } // VkExtent2D extent;
2461 const VkPipelineViewportStateCreateInfo viewportStateParams =
2463 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
2464 DE_NULL, // const void* pNext;
2465 0u, // VkPipelineViewportStateCreateFlags flags;
2466 1u, // deUint32 viewportCount;
2467 &viewport, // const VkViewport* pViewports;
2468 1u, // deUint32 scissorCount;
2469 &scissor // const VkRect2D* pScissors;
2472 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
2474 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
2475 DE_NULL, // const void* pNext;
2476 0u, // VkPipelineRasterizationStateCreateFlags flags;
2477 false, // VkBool32 depthClampEnable;
2478 false, // VkBool32 rasterizerDiscardEnable;
2479 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
2480 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
2481 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
2482 VK_FALSE, // VkBool32 depthBiasEnable;
2483 0.0f, // float depthBiasConstantFactor;
2484 0.0f, // float depthBiasClamp;
2485 0.0f, // float depthBiasSlopeFactor;
2486 1.0f // float lineWidth;
2489 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
2491 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
2492 DE_NULL, // const void* pNext;
2493 0u, // VkPipelineMultisampleStateCreateFlags flags;
2494 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
2495 VK_FALSE, // VkBool32 sampleShadingEnable;
2496 0.0f, // float minSampleShading;
2497 DE_NULL, // const VkSampleMask* pSampleMask;
2498 VK_FALSE, // VkBool32 alphaToCoverageEnable;
2499 VK_FALSE // VkBool32 alphaToOneEnable;
2502 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
2504 false, // VkBool32 blendEnable;
2505 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor;
2506 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendColor;
2507 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
2508 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha;
2509 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendAlpha;
2510 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
2511 (VK_COLOR_COMPONENT_R_BIT |
2512 VK_COLOR_COMPONENT_G_BIT |
2513 VK_COLOR_COMPONENT_B_BIT |
2514 VK_COLOR_COMPONENT_A_BIT) // VkChannelFlags channelWriteMask;
2517 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
2519 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
2520 DE_NULL, // const void* pNext;
2521 0u, // VkPipelineColorBlendStateCreateFlags flags;
2522 false, // VkBool32 logicOpEnable;
2523 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
2524 1u, // deUint32 attachmentCount;
2525 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2526 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
2529 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
2531 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
2532 DE_NULL, // const void* pNext;
2533 0u, // VkPipelineCreateFlags flags;
2534 2u, // deUint32 stageCount;
2535 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
2536 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
2537 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2538 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
2539 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
2540 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
2541 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
2542 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
2543 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
2544 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2545 *pipelineLayout, // VkPipelineLayout layout;
2546 *renderPass, // VkRenderPass renderPass;
2547 0u, // deUint32 subpass;
2548 0u, // VkPipeline basePipelineHandle;
2549 0u // deInt32 basePipelineIndex;
2552 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
2555 // Create command buffer
2557 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2559 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2560 DE_NULL, // const void* pNext;
2561 0u, // VkCommandBufferUsageFlags flags;
2562 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2565 const VkClearValue clearValues[1] =
2567 makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
2570 const VkRenderPassBeginInfo renderPassBeginInfo =
2572 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2573 DE_NULL, // const void* pNext;
2574 *renderPass, // VkRenderPass renderPass;
2575 *framebuffer, // VkFramebuffer framebuffer;
2578 { m_params.src.image.extent.width, m_params.src.image.extent.height }
2579 }, // VkRect2D renderArea;
2580 1u, // deUint32 clearValueCount;
2581 clearValues // const VkClearValue* pClearValues;
2584 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2585 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);
2586 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2588 const VkDeviceSize vertexBufferOffset = 0u;
2590 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
2591 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer.get(), &vertexBufferOffset);
2592 vk.cmdDraw(*m_cmdBuffer, (deUint32)vertices.size(), 1, 0, 0);
2594 vk.cmdEndRenderPass(*m_cmdBuffer);
2595 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2600 const VkQueue queue = m_context.getUniversalQueue();
2601 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2606 tcu::TestStatus ResolveImageToImage::iterate (void)
2608 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2609 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
2611 // upload the destination image
2612 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
2613 (int)m_params.dst.image.extent.width,
2614 (int)m_params.dst.image.extent.height,
2615 (int)m_params.dst.image.extent.depth));
2616 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
2617 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
2619 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
2620 (int)m_params.src.image.extent.width,
2621 (int)m_params.src.image.extent.height,
2622 (int)m_params.dst.image.extent.depth));
2624 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);
2625 generateExpectedResult();
2629 case COPY_MS_IMAGE_TO_MS_IMAGE:
2630 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2631 copyMSImageToMSImage();
2637 const DeviceInterface& vk = m_context.getDeviceInterface();
2638 const VkDevice vkDevice = m_context.getDevice();
2639 const VkQueue queue = m_context.getUniversalQueue();
2640 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
2642 std::vector<VkImageResolve> imageResolves;
2643 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2644 imageResolves.push_back(m_params.regions[i].imageResolve);
2646 const VkImageMemoryBarrier imageBarriers[] =
2650 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2651 DE_NULL, // const void* pNext;
2652 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2653 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2654 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2655 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2656 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2657 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2658 m_multisampledImage.get(), // VkImage image;
2659 { // VkImageSubresourceRange subresourceRange;
2660 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2661 0u, // deUint32 baseMipLevel;
2662 1u, // deUint32 mipLevels;
2663 0u, // deUint32 baseArraySlice;
2664 getArraySize(m_params.dst.image) // deUint32 arraySize;
2667 // destination image
2669 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2670 DE_NULL, // const void* pNext;
2671 0u, // VkAccessFlags srcAccessMask;
2672 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2673 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2674 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2675 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2676 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2677 m_destination.get(), // VkImage image;
2678 { // VkImageSubresourceRange subresourceRange;
2679 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2680 0u, // deUint32 baseMipLevel;
2681 1u, // deUint32 mipLevels;
2682 0u, // deUint32 baseArraySlice;
2683 getArraySize(m_params.dst.image) // deUint32 arraySize;
2688 const VkImageMemoryBarrier postImageBarrier =
2690 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2691 DE_NULL, // const void* pNext;
2692 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2693 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2694 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2695 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2696 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2697 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2698 m_destination.get(), // VkImage image;
2699 { // VkImageSubresourceRange subresourceRange;
2700 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2701 0u, // deUint32 baseMipLevel;
2702 1u, // deUint32 mipLevels;
2703 0u, // deUint32 baseArraySlice;
2704 getArraySize(m_params.dst.image) // deUint32 arraySize;
2708 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2710 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2711 DE_NULL, // const void* pNext;
2712 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2713 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2716 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2717 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);
2718 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());
2719 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);
2720 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2721 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
2723 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image);
2725 return checkTestResult(resultTextureLevel->getAccess());
2728 tcu::TestStatus ResolveImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
2730 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
2731 const float fuzzyThreshold = 0.01f;
2733 for (int arrayLayerNdx = 0; arrayLayerNdx < (int)getArraySize(m_params.dst.image); ++arrayLayerNdx)
2735 const tcu::ConstPixelBufferAccess expectedSub = getSubregion (expected, 0, 0, arrayLayerNdx, expected.getWidth(), expected.getHeight(), 1u);
2736 const tcu::ConstPixelBufferAccess resultSub = getSubregion (result, 0, 0, arrayLayerNdx, result.getWidth(), result.getHeight(), 1u);
2737 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedSub, resultSub, fuzzyThreshold, tcu::COMPARE_LOG_RESULT))
2738 return tcu::TestStatus::fail("CopiesAndBlitting test");
2741 return tcu::TestStatus::pass("CopiesAndBlitting test");
2744 void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2746 VkOffset3D srcOffset = region.imageResolve.srcOffset;
2747 srcOffset.z = region.imageResolve.srcSubresource.baseArrayLayer;
2748 VkOffset3D dstOffset = region.imageResolve.dstOffset;
2749 dstOffset.z = region.imageResolve.dstSubresource.baseArrayLayer;
2750 VkExtent3D extent = region.imageResolve.extent;
2752 const tcu::ConstPixelBufferAccess srcSubRegion = getSubregion (src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
2753 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
2754 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
2755 const tcu::PixelBufferAccess dstSubRegion = getSubregion (dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
2757 tcu::copy(dstSubRegion, srcSubRegion);
2760 void ResolveImageToImage::copyMSImageToMSImage (void)
2762 const DeviceInterface& vk = m_context.getDeviceInterface();
2763 const VkDevice vkDevice = m_context.getDevice();
2764 const VkQueue queue = m_context.getUniversalQueue();
2765 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2766 std::vector<VkImageCopy> imageCopies;
2768 for (deUint32 layerNdx = 0; layerNdx < getArraySize(m_params.dst.image); ++layerNdx)
2770 const VkImageSubresourceLayers sourceSubresourceLayers =
2772 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2773 0u, // uint32_t mipLevel;
2774 0u, // uint32_t baseArrayLayer;
2775 1u // uint32_t layerCount;
2778 const VkImageSubresourceLayers destinationSubresourceLayers =
2780 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;//getAspectFlags(dstTcuFormat)
2781 0u, // uint32_t mipLevel;
2782 layerNdx, // uint32_t baseArrayLayer;
2783 1u // uint32_t layerCount;
2786 const VkImageCopy imageCopy =
2788 sourceSubresourceLayers, // VkImageSubresourceLayers srcSubresource;
2789 {0, 0, 0}, // VkOffset3D srcOffset;
2790 destinationSubresourceLayers, // VkImageSubresourceLayers dstSubresource;
2791 {0, 0, 0}, // VkOffset3D dstOffset;
2792 getExtent3D(m_params.src.image), // VkExtent3D extent;
2794 imageCopies.push_back(imageCopy);
2797 const VkImageMemoryBarrier imageBarriers[] =
2801 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2802 DE_NULL, // const void* pNext;
2803 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2804 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2805 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2806 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2807 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2808 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2809 m_multisampledImage.get(), // VkImage image;
2810 { // VkImageSubresourceRange subresourceRange;
2811 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2812 0u, // deUint32 baseMipLevel;
2813 1u, // deUint32 mipLevels;
2814 0u, // deUint32 baseArraySlice;
2815 getArraySize(m_params.src.image) // deUint32 arraySize;
2818 // destination image
2820 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2821 DE_NULL, // const void* pNext;
2822 0, // VkAccessFlags srcAccessMask;
2823 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2824 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2825 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2826 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2827 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2828 m_multisampledCopyImage.get(), // VkImage image;
2829 { // VkImageSubresourceRange subresourceRange;
2830 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2831 0u, // deUint32 baseMipLevel;
2832 1u, // deUint32 mipLevels;
2833 0u, // deUint32 baseArraySlice;
2834 getArraySize(m_params.dst.image) // deUint32 arraySize;
2839 const VkImageMemoryBarrier postImageBarriers =
2842 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2843 DE_NULL, // const void* pNext;
2844 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2845 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2846 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2847 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2848 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2849 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2850 m_multisampledCopyImage.get(), // VkImage image;
2851 { // VkImageSubresourceRange subresourceRange;
2852 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2853 0u, // deUint32 baseMipLevel;
2854 1u, // deUint32 mipLevels;
2855 0u, // deUint32 baseArraySlice;
2856 getArraySize(m_params.dst.image) // deUint32 arraySize;
2860 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2862 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2863 DE_NULL, // const void* pNext;
2864 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2865 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2868 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2869 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);
2870 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());
2871 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);
2872 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2874 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2876 m_multisampledImage = m_multisampledCopyImage;
2879 class ResolveImageToImageTestCase : public vkt::TestCase
2882 ResolveImageToImageTestCase (tcu::TestContext& testCtx,
2883 const std::string& name,
2884 const std::string& description,
2885 const TestParams params,
2886 const ResolveImageToImageOptions options = NO_OPTIONAL_OPERATION)
2887 : vkt::TestCase (testCtx, name, description)
2889 , m_options (options)
2891 virtual void initPrograms (SourceCollections& programCollection) const;
2893 virtual TestInstance* createInstance (Context& context) const
2895 return new ResolveImageToImage(context, m_params, m_options);
2898 TestParams m_params;
2899 const ResolveImageToImageOptions m_options;
2902 void ResolveImageToImageTestCase::initPrograms (SourceCollections& programCollection) const
2904 programCollection.glslSources.add("vert") << glu::VertexSource(
2906 "layout (location = 0) in highp vec4 a_position;\n"
2909 " gl_Position = a_position;\n"
2913 programCollection.glslSources.add("frag") << glu::FragmentSource(
2915 "layout (location = 0) out highp vec4 o_color;\n"
2918 " o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
2922 std::string getSampleCountCaseName (VkSampleCountFlagBits sampleFlag)
2924 return de::toLower(de::toString(getSampleCountFlagsStr(sampleFlag)).substr(16));
2927 std::string getFormatCaseName (VkFormat format)
2929 return de::toLower(de::toString(getFormatStr(format)).substr(10));
2932 void addCopyImageTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
2933 tcu::TestContext& testCtx,
2936 const VkFormat compatibleFormats8Bit[] =
2938 VK_FORMAT_R4G4_UNORM_PACK8,
2941 VK_FORMAT_R8_USCALED,
2942 VK_FORMAT_R8_SSCALED,
2949 const VkFormat compatibleFormats16Bit[] =
2951 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
2952 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
2953 VK_FORMAT_R5G6B5_UNORM_PACK16,
2954 VK_FORMAT_B5G6R5_UNORM_PACK16,
2955 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
2956 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
2957 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
2958 VK_FORMAT_R8G8_UNORM,
2959 VK_FORMAT_R8G8_SNORM,
2960 VK_FORMAT_R8G8_USCALED,
2961 VK_FORMAT_R8G8_SSCALED,
2962 VK_FORMAT_R8G8_UINT,
2963 VK_FORMAT_R8G8_SINT,
2964 VK_FORMAT_R8G8_SRGB,
2965 VK_FORMAT_R16_UNORM,
2966 VK_FORMAT_R16_SNORM,
2967 VK_FORMAT_R16_USCALED,
2968 VK_FORMAT_R16_SSCALED,
2971 VK_FORMAT_R16_SFLOAT,
2975 const VkFormat compatibleFormats24Bit[] =
2977 VK_FORMAT_R8G8B8_UNORM,
2978 VK_FORMAT_R8G8B8_SNORM,
2979 VK_FORMAT_R8G8B8_USCALED,
2980 VK_FORMAT_R8G8B8_SSCALED,
2981 VK_FORMAT_R8G8B8_UINT,
2982 VK_FORMAT_R8G8B8_SINT,
2983 VK_FORMAT_R8G8B8_SRGB,
2984 VK_FORMAT_B8G8R8_UNORM,
2985 VK_FORMAT_B8G8R8_SNORM,
2986 VK_FORMAT_B8G8R8_USCALED,
2987 VK_FORMAT_B8G8R8_SSCALED,
2988 VK_FORMAT_B8G8R8_UINT,
2989 VK_FORMAT_B8G8R8_SINT,
2990 VK_FORMAT_B8G8R8_SRGB,
2994 const VkFormat compatibleFormats32Bit[] =
2996 VK_FORMAT_R8G8B8A8_UNORM,
2997 VK_FORMAT_R8G8B8A8_SNORM,
2998 VK_FORMAT_R8G8B8A8_USCALED,
2999 VK_FORMAT_R8G8B8A8_SSCALED,
3000 VK_FORMAT_R8G8B8A8_UINT,
3001 VK_FORMAT_R8G8B8A8_SINT,
3002 VK_FORMAT_R8G8B8A8_SRGB,
3003 VK_FORMAT_B8G8R8A8_UNORM,
3004 VK_FORMAT_B8G8R8A8_SNORM,
3005 VK_FORMAT_B8G8R8A8_USCALED,
3006 VK_FORMAT_B8G8R8A8_SSCALED,
3007 VK_FORMAT_B8G8R8A8_UINT,
3008 VK_FORMAT_B8G8R8A8_SINT,
3009 VK_FORMAT_B8G8R8A8_SRGB,
3010 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3011 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3012 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3013 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3014 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3015 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3016 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3017 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3018 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3019 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3020 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3021 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3022 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3023 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3024 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3025 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3026 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3027 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3028 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3029 VK_FORMAT_R16G16_UNORM,
3030 VK_FORMAT_R16G16_SNORM,
3031 VK_FORMAT_R16G16_USCALED,
3032 VK_FORMAT_R16G16_SSCALED,
3033 VK_FORMAT_R16G16_UINT,
3034 VK_FORMAT_R16G16_SINT,
3035 VK_FORMAT_R16G16_SFLOAT,
3038 VK_FORMAT_R32_SFLOAT,
3042 const VkFormat compatibleFormats48Bit[] =
3044 VK_FORMAT_R16G16B16_UNORM,
3045 VK_FORMAT_R16G16B16_SNORM,
3046 VK_FORMAT_R16G16B16_USCALED,
3047 VK_FORMAT_R16G16B16_SSCALED,
3048 VK_FORMAT_R16G16B16_UINT,
3049 VK_FORMAT_R16G16B16_SINT,
3050 VK_FORMAT_R16G16B16_SFLOAT,
3054 const VkFormat compatibleFormats64Bit[] =
3056 VK_FORMAT_R16G16B16A16_UNORM,
3057 VK_FORMAT_R16G16B16A16_SNORM,
3058 VK_FORMAT_R16G16B16A16_USCALED,
3059 VK_FORMAT_R16G16B16A16_SSCALED,
3060 VK_FORMAT_R16G16B16A16_UINT,
3061 VK_FORMAT_R16G16B16A16_SINT,
3062 VK_FORMAT_R16G16B16A16_SFLOAT,
3063 VK_FORMAT_R32G32_UINT,
3064 VK_FORMAT_R32G32_SINT,
3065 VK_FORMAT_R32G32_SFLOAT,
3068 VK_FORMAT_R64_SFLOAT,
3072 const VkFormat compatibleFormats96Bit[] =
3074 VK_FORMAT_R32G32B32_UINT,
3075 VK_FORMAT_R32G32B32_SINT,
3076 VK_FORMAT_R32G32B32_SFLOAT,
3080 const VkFormat compatibleFormats128Bit[] =
3082 VK_FORMAT_R32G32B32A32_UINT,
3083 VK_FORMAT_R32G32B32A32_SINT,
3084 VK_FORMAT_R32G32B32A32_SFLOAT,
3085 VK_FORMAT_R64G64_UINT,
3086 VK_FORMAT_R64G64_SINT,
3087 VK_FORMAT_R64G64_SFLOAT,
3091 const VkFormat compatibleFormats192Bit[] =
3093 VK_FORMAT_R64G64B64_UINT,
3094 VK_FORMAT_R64G64B64_SINT,
3095 VK_FORMAT_R64G64B64_SFLOAT,
3099 const VkFormat compatibleFormats256Bit[] =
3101 VK_FORMAT_R64G64B64A64_UINT,
3102 VK_FORMAT_R64G64B64A64_SINT,
3103 VK_FORMAT_R64G64B64A64_SFLOAT,
3108 const VkFormat* colorImageFormatsToTest[] =
3110 compatibleFormats8Bit,
3111 compatibleFormats16Bit,
3112 compatibleFormats24Bit,
3113 compatibleFormats32Bit,
3114 compatibleFormats48Bit,
3115 compatibleFormats64Bit,
3116 compatibleFormats96Bit,
3117 compatibleFormats128Bit,
3118 compatibleFormats192Bit,
3119 compatibleFormats256Bit,
3121 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3123 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3125 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex];
3126 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3128 params.src.image.format = compatibleFormats[srcFormatIndex];
3129 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3131 params.dst.image.format = compatibleFormats[dstFormatIndex];
3132 std::ostringstream testName;
3133 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3134 std::ostringstream description;
3135 description << "Copy from src " << params.src.image.format << " to dst " << params.dst.image.format;
3137 testCaseGroup->addChild(new CopyImageToImageTestCase(testCtx, testName.str(), description.str(), params));
3143 void addBlittingTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3144 tcu::TestContext& testCtx,
3147 // Test Image formats.
3148 const VkFormat compatibleFormatsUInts[] =
3151 VK_FORMAT_R8G8_UINT,
3152 VK_FORMAT_R8G8B8_UINT,
3153 VK_FORMAT_B8G8R8_UINT,
3154 VK_FORMAT_R8G8B8A8_UINT,
3155 VK_FORMAT_B8G8R8A8_UINT,
3156 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3157 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3158 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3160 VK_FORMAT_R16G16_UINT,
3161 VK_FORMAT_R16G16B16_UINT,
3162 VK_FORMAT_R16G16B16A16_UINT,
3164 VK_FORMAT_R32G32_UINT,
3165 VK_FORMAT_R32G32B32_UINT,
3166 VK_FORMAT_R32G32B32A32_UINT,
3168 VK_FORMAT_R64G64_UINT,
3169 VK_FORMAT_R64G64B64_UINT,
3170 VK_FORMAT_R64G64B64A64_UINT,
3174 const VkFormat compatibleFormatsSInts[] =
3177 VK_FORMAT_R8G8_SINT,
3178 VK_FORMAT_R8G8B8_SINT,
3179 VK_FORMAT_B8G8R8_SINT,
3180 VK_FORMAT_R8G8B8A8_SINT,
3181 VK_FORMAT_B8G8R8A8_SINT,
3182 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3183 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3184 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3186 VK_FORMAT_R16G16_SINT,
3187 VK_FORMAT_R16G16B16_SINT,
3188 VK_FORMAT_R16G16B16A16_SINT,
3190 VK_FORMAT_R32G32_SINT,
3191 VK_FORMAT_R32G32B32_SINT,
3192 VK_FORMAT_R32G32B32A32_SINT,
3194 VK_FORMAT_R64G64_SINT,
3195 VK_FORMAT_R64G64B64_SINT,
3196 VK_FORMAT_R64G64B64A64_SINT,
3200 const VkFormat compatibleFormatsFloats[] =
3202 VK_FORMAT_R4G4_UNORM_PACK8,
3203 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3204 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3205 VK_FORMAT_R5G6B5_UNORM_PACK16,
3206 VK_FORMAT_B5G6R5_UNORM_PACK16,
3207 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3208 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3209 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3212 VK_FORMAT_R8_USCALED,
3213 VK_FORMAT_R8_SSCALED,
3214 VK_FORMAT_R8G8_UNORM,
3215 VK_FORMAT_R8G8_SNORM,
3216 VK_FORMAT_R8G8_USCALED,
3217 VK_FORMAT_R8G8_SSCALED,
3218 VK_FORMAT_R8G8B8_UNORM,
3219 VK_FORMAT_R8G8B8_SNORM,
3220 VK_FORMAT_R8G8B8_USCALED,
3221 VK_FORMAT_R8G8B8_SSCALED,
3222 VK_FORMAT_B8G8R8_UNORM,
3223 VK_FORMAT_B8G8R8_SNORM,
3224 VK_FORMAT_B8G8R8_USCALED,
3225 VK_FORMAT_B8G8R8_SSCALED,
3226 VK_FORMAT_R8G8B8A8_UNORM,
3227 VK_FORMAT_R8G8B8A8_SNORM,
3228 VK_FORMAT_R8G8B8A8_USCALED,
3229 VK_FORMAT_R8G8B8A8_SSCALED,
3230 VK_FORMAT_B8G8R8A8_UNORM,
3231 VK_FORMAT_B8G8R8A8_SNORM,
3232 VK_FORMAT_B8G8R8A8_USCALED,
3233 VK_FORMAT_B8G8R8A8_SSCALED,
3234 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3235 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3236 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3237 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3238 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3239 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3240 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3241 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3242 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3243 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3244 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3245 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3246 VK_FORMAT_R16_UNORM,
3247 VK_FORMAT_R16_SNORM,
3248 VK_FORMAT_R16_USCALED,
3249 VK_FORMAT_R16_SSCALED,
3250 VK_FORMAT_R16_SFLOAT,
3251 VK_FORMAT_R16G16_UNORM,
3252 VK_FORMAT_R16G16_SNORM,
3253 VK_FORMAT_R16G16_USCALED,
3254 VK_FORMAT_R16G16_SSCALED,
3255 VK_FORMAT_R16G16_SFLOAT,
3256 VK_FORMAT_R16G16B16_UNORM,
3257 VK_FORMAT_R16G16B16_SNORM,
3258 VK_FORMAT_R16G16B16_USCALED,
3259 VK_FORMAT_R16G16B16_SSCALED,
3260 VK_FORMAT_R16G16B16_SFLOAT,
3261 VK_FORMAT_R16G16B16A16_UNORM,
3262 VK_FORMAT_R16G16B16A16_SNORM,
3263 VK_FORMAT_R16G16B16A16_USCALED,
3264 VK_FORMAT_R16G16B16A16_SSCALED,
3265 VK_FORMAT_R16G16B16A16_SFLOAT,
3266 VK_FORMAT_R32_SFLOAT,
3267 VK_FORMAT_R32G32_SFLOAT,
3268 VK_FORMAT_R32G32B32_SFLOAT,
3269 VK_FORMAT_R32G32B32A32_SFLOAT,
3270 VK_FORMAT_R64_SFLOAT,
3271 VK_FORMAT_R64G64_SFLOAT,
3272 VK_FORMAT_R64G64B64_SFLOAT,
3273 VK_FORMAT_R64G64B64A64_SFLOAT,
3274 // VK_FORMAT_B10G11R11_UFLOAT_PACK32,
3275 // VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
3276 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3277 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3278 // VK_FORMAT_BC2_UNORM_BLOCK,
3279 // VK_FORMAT_BC3_UNORM_BLOCK,
3280 // VK_FORMAT_BC4_UNORM_BLOCK,
3281 // VK_FORMAT_BC4_SNORM_BLOCK,
3282 // VK_FORMAT_BC5_UNORM_BLOCK,
3283 // VK_FORMAT_BC5_SNORM_BLOCK,
3284 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
3285 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
3286 // VK_FORMAT_BC7_UNORM_BLOCK,
3287 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3288 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3289 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3290 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
3291 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
3292 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3293 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3294 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3295 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3296 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3297 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3298 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3299 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3300 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3301 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3302 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3303 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3304 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3305 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3306 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3307 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3311 const VkFormat compatibleFormatsSrgb[] =
3314 VK_FORMAT_R8G8_SRGB,
3315 VK_FORMAT_R8G8B8_SRGB,
3316 VK_FORMAT_B8G8R8_SRGB,
3317 VK_FORMAT_R8G8B8A8_SRGB,
3318 VK_FORMAT_B8G8R8A8_SRGB,
3319 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3320 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3321 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3322 // VK_FORMAT_BC2_SRGB_BLOCK,
3323 // VK_FORMAT_BC3_SRGB_BLOCK,
3324 // VK_FORMAT_BC7_SRGB_BLOCK,
3325 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3326 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3327 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3328 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3329 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3330 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3331 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3332 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3333 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3334 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3335 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3336 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3337 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3338 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3339 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3340 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3341 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3347 const VkFormat* compatibleFormats;
3348 const bool onlyNearest;
3349 } colorImageFormatsToTest[] =
3351 { compatibleFormatsUInts, true },
3352 { compatibleFormatsSInts, true },
3353 { compatibleFormatsFloats, false },
3354 { compatibleFormatsSrgb, false },
3356 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3358 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3360 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex].compatibleFormats;
3361 const bool onlyNearest = colorImageFormatsToTest[compatibleFormatsIndex].onlyNearest;
3362 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3364 params.src.image.format = compatibleFormats[srcFormatIndex];
3365 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3367 params.dst.image.format = compatibleFormats[dstFormatIndex];
3368 std::ostringstream testName;
3369 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3370 std::ostringstream description;
3371 description << "Blit image from src " << params.src.image.format << " to dst " << params.dst.image.format;
3373 params.filter = VK_FILTER_NEAREST;
3374 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_nearest", description.str(), params));
3378 params.filter = VK_FILTER_LINEAR;
3379 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_linear", description.str(), params));
3388 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
3390 de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
3392 de::MovePtr<tcu::TestCaseGroup> imageToImageTests (new tcu::TestCaseGroup(testCtx, "image_to_image", "Copy from image to image"));
3393 de::MovePtr<tcu::TestCaseGroup> imgToImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Copy from image to image simple tests"));
3394 de::MovePtr<tcu::TestCaseGroup> imgToImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Copy from image to image with all compatible formats"));
3395 de::MovePtr<tcu::TestCaseGroup> imgToImg3dImagesTests (new tcu::TestCaseGroup(testCtx, "3d_images", "Coping operations on 3d images"));
3397 de::MovePtr<tcu::TestCaseGroup> imageToBufferTests (new tcu::TestCaseGroup(testCtx, "image_to_buffer", "Copy from image to buffer"));
3398 de::MovePtr<tcu::TestCaseGroup> bufferToImageTests (new tcu::TestCaseGroup(testCtx, "buffer_to_image", "Copy from buffer to image"));
3399 de::MovePtr<tcu::TestCaseGroup> bufferToBufferTests (new tcu::TestCaseGroup(testCtx, "buffer_to_buffer", "Copy from buffer to buffer"));
3401 de::MovePtr<tcu::TestCaseGroup> blittingImageTests (new tcu::TestCaseGroup(testCtx, "blit_image", "Blitting image"));
3402 de::MovePtr<tcu::TestCaseGroup> blitImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Blitting image simple tests"));
3403 de::MovePtr<tcu::TestCaseGroup> blitImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Blitting image with all compatible formats"));
3405 de::MovePtr<tcu::TestCaseGroup> resolveImageTests (new tcu::TestCaseGroup(testCtx, "resolve_image", "Resolve image"));
3407 const deInt32 defaultSize = 64;
3408 const deInt32 defaultHalfSize = defaultSize / 2;
3409 const deInt32 defaultFourthSize = defaultSize / 4;
3410 const VkExtent3D defaultExtent = {defaultSize, defaultSize, 1};
3411 const VkExtent3D defaultHalfExtent = {defaultHalfSize, defaultHalfSize, 1};
3413 const VkImageSubresourceLayers defaultSourceLayer =
3415 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
3416 0u, // uint32_t mipLevel;
3417 0u, // uint32_t baseArrayLayer;
3418 1u, // uint32_t layerCount;
3421 // Copy image to image testcases.
3424 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3425 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3426 params.src.image.extent = defaultExtent;
3427 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3428 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3429 params.dst.image.extent = defaultExtent;
3432 const VkImageCopy testCopy =
3434 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3435 {0, 0, 0}, // VkOffset3D srcOffset;
3436 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3437 {0, 0, 0}, // VkOffset3D dstOffset;
3438 defaultExtent, // VkExtent3D extent;
3441 CopyRegion imageCopy;
3442 imageCopy.imageCopy = testCopy;
3444 params.regions.push_back(imageCopy);
3447 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image", "Whole image", params));
3452 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3453 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3454 params.src.image.extent = defaultExtent;
3455 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3456 params.dst.image.format = VK_FORMAT_R32_UINT;
3457 params.dst.image.extent = defaultExtent;
3460 const VkImageCopy testCopy =
3462 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3463 {0, 0, 0}, // VkOffset3D srcOffset;
3464 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3465 {0, 0, 0}, // VkOffset3D dstOffset;
3466 defaultExtent, // VkExtent3D extent;
3469 CopyRegion imageCopy;
3470 imageCopy.imageCopy = testCopy;
3472 params.regions.push_back(imageCopy);
3475 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image_diff_fromat", "Whole image with different format", params));
3480 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3481 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3482 params.src.image.extent = defaultExtent;
3483 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3484 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3485 params.dst.image.extent = defaultExtent;
3488 const VkImageCopy testCopy =
3490 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3491 {0, 0, 0}, // VkOffset3D srcOffset;
3492 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3493 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3494 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3497 CopyRegion imageCopy;
3498 imageCopy.imageCopy = testCopy;
3500 params.regions.push_back(imageCopy);
3503 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "partial_image", "Partial image", params));
3508 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3509 params.src.image.format = VK_FORMAT_D32_SFLOAT;
3510 params.src.image.extent = defaultExtent;
3511 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3512 params.dst.image.format = VK_FORMAT_D32_SFLOAT;
3513 params.dst.image.extent = defaultExtent;
3516 const VkImageSubresourceLayers sourceLayer =
3518 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
3519 0u, // uint32_t mipLevel;
3520 0u, // uint32_t baseArrayLayer;
3521 1u // uint32_t layerCount;
3523 const VkImageCopy testCopy =
3525 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3526 {0, 0, 0}, // VkOffset3D srcOffset;
3527 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3528 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3529 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3532 CopyRegion imageCopy;
3533 imageCopy.imageCopy = testCopy;
3535 params.regions.push_back(imageCopy);
3538 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "depth", "With depth", params));
3543 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3544 params.src.image.format = VK_FORMAT_S8_UINT;
3545 params.src.image.extent = defaultExtent;
3546 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3547 params.dst.image.format = VK_FORMAT_S8_UINT;
3548 params.dst.image.extent = defaultExtent;
3551 const VkImageSubresourceLayers sourceLayer =
3553 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
3554 0u, // uint32_t mipLevel;
3555 0u, // uint32_t baseArrayLayer;
3556 1u // uint32_t layerCount;
3558 const VkImageCopy testCopy =
3560 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3561 {0, 0, 0}, // VkOffset3D srcOffset;
3562 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3563 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3564 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3567 CopyRegion imageCopy;
3568 imageCopy.imageCopy = testCopy;
3570 params.regions.push_back(imageCopy);
3573 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "stencil", "With stencil", params));
3578 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3579 params.src.image.extent = defaultExtent;
3580 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3581 params.dst.image.extent = defaultExtent;
3583 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3585 const VkImageCopy testCopy =
3587 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3588 {0, 0, 0}, // VkOffset3D srcOffset;
3589 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3590 {i, defaultSize - i - defaultFourthSize, 0}, // VkOffset3D dstOffset;
3591 {defaultFourthSize, defaultFourthSize, 1}, // VkExtent3D extent;
3594 CopyRegion imageCopy;
3595 imageCopy.imageCopy = testCopy;
3597 params.regions.push_back(imageCopy);
3600 addCopyImageTestsAllFormats(imgToImgAllFormatsTests.get(), testCtx, params);
3602 imageToImageTests->addChild(imgToImgSimpleTests.release());
3603 imageToImageTests->addChild(imgToImgAllFormatsTests.release());
3605 // Copy image to buffer testcases.
3608 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3609 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3610 params.src.image.extent = defaultExtent;
3611 params.dst.buffer.size = defaultSize * defaultSize;
3613 const VkBufferImageCopy bufferImageCopy =
3615 0u, // VkDeviceSize bufferOffset;
3616 0u, // uint32_t bufferRowLength;
3617 0u, // uint32_t bufferImageHeight;
3618 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3619 {0, 0, 0}, // VkOffset3D imageOffset;
3620 defaultExtent // VkExtent3D imageExtent;
3622 CopyRegion copyRegion;
3623 copyRegion.bufferImageCopy = bufferImageCopy;
3625 params.regions.push_back(copyRegion);
3627 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "whole", "Copy from image to buffer", params));
3632 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3633 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3634 params.src.image.extent = defaultExtent;
3635 params.dst.buffer.size = defaultSize * defaultSize;
3637 const VkBufferImageCopy bufferImageCopy =
3639 defaultSize * defaultHalfSize, // VkDeviceSize bufferOffset;
3640 0u, // uint32_t bufferRowLength;
3641 0u, // uint32_t bufferImageHeight;
3642 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3643 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3644 defaultHalfExtent // VkExtent3D imageExtent;
3646 CopyRegion copyRegion;
3647 copyRegion.bufferImageCopy = bufferImageCopy;
3649 params.regions.push_back(copyRegion);
3651 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "buffer_offset", "Copy from image to buffer with buffer offset", params));
3656 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3657 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3658 params.src.image.extent = defaultExtent;
3659 params.dst.buffer.size = defaultSize * defaultSize;
3661 const int pixelSize = tcu::getPixelSize(mapVkFormat(params.src.image.format));
3662 const VkDeviceSize bufferSize = pixelSize * params.dst.buffer.size;
3663 const VkDeviceSize offsetSize = pixelSize * defaultFourthSize * defaultFourthSize;
3664 deUint32 divisor = 1;
3665 for (VkDeviceSize offset = 0; offset < bufferSize - offsetSize; offset += offsetSize, ++divisor)
3667 const deUint32 bufferRowLength = defaultFourthSize;
3668 const deUint32 bufferImageHeight = defaultFourthSize;
3669 const VkExtent3D imageExtent = {defaultFourthSize / divisor, defaultFourthSize, 1};
3670 DE_ASSERT(!bufferRowLength || bufferRowLength >= imageExtent.width);
3671 DE_ASSERT(!bufferImageHeight || bufferImageHeight >= imageExtent.height);
3672 DE_ASSERT(imageExtent.width * imageExtent.height *imageExtent.depth <= offsetSize);
3675 const VkBufferImageCopy bufferImageCopy =
3677 offset, // VkDeviceSize bufferOffset;
3678 bufferRowLength, // uint32_t bufferRowLength;
3679 bufferImageHeight, // uint32_t bufferImageHeight;
3680 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3681 {0, 0, 0}, // VkOffset3D imageOffset;
3682 imageExtent // VkExtent3D imageExtent;
3684 region.bufferImageCopy = bufferImageCopy;
3685 params.regions.push_back(region);
3688 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "regions", "Copy from image to buffer with multiple regions", params));
3691 // Copy buffer to image testcases.
3694 params.src.buffer.size = defaultSize * defaultSize;
3695 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3696 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3697 params.dst.image.extent = defaultExtent;
3699 const VkBufferImageCopy bufferImageCopy =
3701 0u, // VkDeviceSize bufferOffset;
3702 0u, // uint32_t bufferRowLength;
3703 0u, // uint32_t bufferImageHeight;
3704 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3705 {0, 0, 0}, // VkOffset3D imageOffset;
3706 defaultExtent // VkExtent3D imageExtent;
3708 CopyRegion copyRegion;
3709 copyRegion.bufferImageCopy = bufferImageCopy;
3711 params.regions.push_back(copyRegion);
3713 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "whole", "Copy from buffer to image", params));
3718 params.src.buffer.size = defaultSize * defaultSize;
3719 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3720 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3721 params.dst.image.extent = defaultExtent;
3724 deUint32 divisor = 1;
3725 for (int offset = 0; (offset + defaultFourthSize / divisor < defaultSize) && (defaultFourthSize > divisor); offset += defaultFourthSize / divisor++)
3727 const VkBufferImageCopy bufferImageCopy =
3729 0u, // VkDeviceSize bufferOffset;
3730 0u, // uint32_t bufferRowLength;
3731 0u, // uint32_t bufferImageHeight;
3732 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3733 {offset, defaultHalfSize, 0}, // VkOffset3D imageOffset;
3734 {defaultFourthSize / divisor, defaultFourthSize / divisor, 1} // VkExtent3D imageExtent;
3736 region.bufferImageCopy = bufferImageCopy;
3737 params.regions.push_back(region);
3740 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "regions", "Copy from buffer to image with multiple regions", params));
3745 params.src.buffer.size = defaultSize * defaultSize;
3746 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3747 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3748 params.dst.image.extent = defaultExtent;
3750 const VkBufferImageCopy bufferImageCopy =
3752 defaultFourthSize, // VkDeviceSize bufferOffset;
3753 defaultHalfSize + defaultFourthSize, // uint32_t bufferRowLength;
3754 defaultHalfSize + defaultFourthSize, // uint32_t bufferImageHeight;
3755 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3756 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3757 defaultHalfExtent // VkExtent3D imageExtent;
3759 CopyRegion copyRegion;
3760 copyRegion.bufferImageCopy = bufferImageCopy;
3762 params.regions.push_back(copyRegion);
3764 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_offset", "Copy from buffer to image with buffer offset", params));
3767 // Copy buffer to buffer testcases.
3770 params.src.buffer.size = defaultSize;
3771 params.dst.buffer.size = defaultSize;
3773 const VkBufferCopy bufferCopy =
3775 0u, // VkDeviceSize srcOffset;
3776 0u, // VkDeviceSize dstOffset;
3777 defaultSize, // VkDeviceSize size;
3780 CopyRegion copyRegion;
3781 copyRegion.bufferCopy = bufferCopy;
3782 params.regions.push_back(copyRegion);
3784 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
3789 params.src.buffer.size = defaultFourthSize;
3790 params.dst.buffer.size = defaultFourthSize;
3792 const VkBufferCopy bufferCopy =
3794 12u, // VkDeviceSize srcOffset;
3795 4u, // VkDeviceSize dstOffset;
3796 1u, // VkDeviceSize size;
3799 CopyRegion copyRegion;
3800 copyRegion.bufferCopy = bufferCopy;
3801 params.regions.push_back(copyRegion);
3803 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "partial", "Partial", params));
3807 const deUint32 size = 16;
3809 params.src.buffer.size = size;
3810 params.dst.buffer.size = size * (size + 1);
3812 // Copy region with size 1..size
3813 for (unsigned int i = 1; i <= size; i++)
3815 const VkBufferCopy bufferCopy =
3817 0, // VkDeviceSize srcOffset;
3818 i * size, // VkDeviceSize dstOffset;
3819 i, // VkDeviceSize size;
3822 CopyRegion copyRegion;
3823 copyRegion.bufferCopy = bufferCopy;
3824 params.regions.push_back(copyRegion);
3827 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "regions", "Multiple regions", params));
3830 // Blitting testcases.
3832 const std::string description ("Blit without scaling (whole)");
3833 const std::string testName ("whole");
3836 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3837 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3838 params.src.image.extent = defaultExtent;
3839 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3840 params.dst.image.extent = defaultExtent;
3843 const VkImageBlit imageBlit =
3845 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3848 {defaultSize, defaultSize, 1}
3849 }, // VkOffset3D srcOffsets[2];
3851 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3854 {defaultSize, defaultSize, 1}
3855 } // VkOffset3D dstOffset[2];
3859 region.imageBlit = imageBlit;
3860 params.regions.push_back(region);
3863 // Filter is VK_FILTER_NEAREST.
3865 params.filter = VK_FILTER_NEAREST;
3867 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3868 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
3870 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3871 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
3872 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
3874 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3875 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
3876 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
3879 // Filter is VK_FILTER_LINEAR.
3881 params.filter = VK_FILTER_LINEAR;
3883 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3884 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
3886 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3887 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
3888 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
3890 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3891 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
3892 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
3897 const std::string description ("Flipping x and y coordinates (whole)");
3898 const std::string testName ("mirror_xy");
3901 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3902 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3903 params.src.image.extent = defaultExtent;
3904 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3905 params.dst.image.extent = defaultExtent;
3908 const VkImageBlit imageBlit =
3910 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3913 {defaultSize, defaultSize, 1}
3914 }, // VkOffset3D srcOffsets[2];
3916 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3918 {defaultSize, defaultSize, 1},
3920 } // VkOffset3D dstOffset[2];
3924 region.imageBlit = imageBlit;
3925 params.regions.push_back(region);
3928 // Filter is VK_FILTER_NEAREST.
3930 params.filter = VK_FILTER_NEAREST;
3932 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3933 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
3935 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3936 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
3937 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
3939 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3940 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
3941 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
3944 // Filter is VK_FILTER_LINEAR.
3946 params.filter = VK_FILTER_LINEAR;
3948 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3949 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
3951 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
3952 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
3953 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
3955 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
3956 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
3957 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
3962 const std::string description ("Flipping x coordinates (whole)");
3963 const std::string testName ("mirror_x");
3966 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3967 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3968 params.src.image.extent = defaultExtent;
3969 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3970 params.dst.image.extent = defaultExtent;
3973 const VkImageBlit imageBlit =
3975 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3978 {defaultSize, defaultSize, 1}
3979 }, // VkOffset3D srcOffsets[2];
3981 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3983 {defaultSize, 0, 0},
3985 } // VkOffset3D dstOffset[2];
3989 region.imageBlit = imageBlit;
3990 params.regions.push_back(region);
3993 // Filter is VK_FILTER_NEAREST.
3995 params.filter = VK_FILTER_NEAREST;
3997 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3998 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4000 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4001 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4002 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4004 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4005 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4006 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4009 // Filter is VK_FILTER_LINEAR.
4011 params.filter = VK_FILTER_LINEAR;
4013 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4014 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4016 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4017 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4018 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4020 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4021 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4022 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4027 const std::string description ("Flipping Y coordinates (whole)");
4028 const std::string testName ("mirror_y");
4031 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4032 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4033 params.src.image.extent = defaultExtent;
4034 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4035 params.dst.image.extent = defaultExtent;
4038 const VkImageBlit imageBlit =
4040 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4043 {defaultSize, defaultSize, 1}
4044 }, // VkOffset3D srcOffsets[2];
4046 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4048 {0, defaultSize, 1},
4050 } // VkOffset3D dstOffset[2];
4054 region.imageBlit = imageBlit;
4055 params.regions.push_back(region);
4058 // Filter is VK_FILTER_NEAREST.
4060 params.filter = VK_FILTER_NEAREST;
4062 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4063 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4065 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4066 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4067 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4069 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4070 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4071 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4074 // Filter is VK_FILTER_LINEAR.
4076 params.filter = VK_FILTER_LINEAR;
4078 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4079 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4081 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4082 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4083 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4085 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4086 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4087 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4092 const std::string description ("Mirroring subregions in image (no flip ,y flip ,x flip, xy flip)");
4093 const std::string testName ("mirror_subregions");
4096 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4097 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4098 params.src.image.extent = defaultExtent;
4099 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4100 params.dst.image.extent = defaultExtent;
4104 const VkImageBlit imageBlit =
4106 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4109 {defaultHalfSize, defaultHalfSize, 1}
4110 }, // VkOffset3D srcOffsets[2];
4112 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4115 {defaultHalfSize, defaultHalfSize, 1}
4116 } // VkOffset3D dstOffset[2];
4120 region.imageBlit = imageBlit;
4121 params.regions.push_back(region);
4124 // Flipping y coordinates.
4126 const VkImageBlit imageBlit =
4128 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4130 {defaultHalfSize, 0, 0},
4131 {defaultSize, defaultHalfSize, 1}
4132 }, // VkOffset3D srcOffsets[2];
4134 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4136 {defaultHalfSize, defaultHalfSize, 0},
4138 } // VkOffset3D dstOffset[2];
4142 region.imageBlit = imageBlit;
4143 params.regions.push_back(region);
4146 // Flipping x coordinates.
4148 const VkImageBlit imageBlit =
4150 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4152 {0, defaultHalfSize, 0},
4153 {defaultHalfSize, defaultSize, 1}
4154 }, // VkOffset3D srcOffsets[2];
4156 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4158 {defaultHalfSize, defaultHalfSize, 0},
4160 } // VkOffset3D dstOffset[2];
4164 region.imageBlit = imageBlit;
4165 params.regions.push_back(region);
4168 // Flipping x and y coordinates.
4170 const VkImageBlit imageBlit =
4172 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4174 {defaultHalfSize, defaultHalfSize, 0},
4175 {defaultSize, defaultSize, 1}
4176 }, // VkOffset3D srcOffsets[2];
4178 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4180 {defaultSize, defaultSize, 0},
4181 {defaultHalfSize, defaultHalfSize, 1}
4182 } // VkOffset3D dstOffset[2];
4186 region.imageBlit = imageBlit;
4187 params.regions.push_back(region);
4190 // Filter is VK_FILTER_NEAREST.
4192 params.filter = VK_FILTER_NEAREST;
4194 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4195 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4197 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4198 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4199 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4201 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4202 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4203 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4206 // Filter is VK_FILTER_LINEAR.
4208 params.filter = VK_FILTER_LINEAR;
4210 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4211 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4213 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4214 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4215 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4217 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4218 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4219 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4224 const std::string description ("Blit with scaling (whole, src extent bigger)");
4225 const std::string testName ("scaling_whole1");
4228 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4229 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4230 params.src.image.extent = defaultExtent;
4231 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4232 params.dst.image.extent = defaultHalfExtent;
4235 const VkImageBlit imageBlit =
4237 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4240 {defaultSize, defaultSize, 1}
4241 }, // VkOffset3D srcOffsets[2];
4243 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4246 {defaultHalfSize, defaultHalfSize, 1}
4247 } // VkOffset3D dstOffset[2];
4251 region.imageBlit = imageBlit;
4252 params.regions.push_back(region);
4255 // Filter is VK_FILTER_NEAREST.
4257 params.filter = VK_FILTER_NEAREST;
4259 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4260 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4262 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4263 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4264 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4266 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4267 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4268 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4271 // Filter is VK_FILTER_LINEAR.
4273 params.filter = VK_FILTER_LINEAR;
4275 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4276 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4278 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4279 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4280 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4282 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4283 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4284 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4289 const std::string description ("Blit with scaling (whole, dst extent bigger)");
4290 const std::string testName ("scaling_whole2");
4293 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4294 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4295 params.src.image.extent = defaultHalfExtent;
4296 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4297 params.dst.image.extent = defaultExtent;
4300 const VkImageBlit imageBlit =
4302 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4305 {defaultHalfSize, defaultHalfSize, 1}
4306 }, // VkOffset3D srcOffsets[2];
4308 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4311 {defaultSize, defaultSize, 1}
4312 } // VkOffset3D dstOffset[2];
4316 region.imageBlit = imageBlit;
4317 params.regions.push_back(region);
4320 // Filter is VK_FILTER_NEAREST.
4322 params.filter = VK_FILTER_NEAREST;
4324 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4325 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4327 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4328 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4329 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4331 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4332 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4333 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4336 // Filter is VK_FILTER_LINEAR.
4338 params.filter = VK_FILTER_LINEAR;
4340 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4341 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4343 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4344 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4345 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4347 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4348 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4349 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4354 const std::string description ("Blit with scaling and offset (whole, dst extent bigger)");
4355 const std::string testName ("scaling_and_offset");
4358 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4359 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4360 params.src.image.extent = defaultExtent;
4361 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4362 params.dst.image.extent = defaultExtent;
4365 const VkImageBlit imageBlit =
4367 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4369 {defaultFourthSize, defaultFourthSize, 0},
4370 {defaultFourthSize*3, defaultFourthSize*3, 1}
4371 }, // VkOffset3D srcOffsets[2];
4373 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4376 {defaultSize, defaultSize, 1}
4377 } // VkOffset3D dstOffset[2];
4381 region.imageBlit = imageBlit;
4382 params.regions.push_back(region);
4385 // Filter is VK_FILTER_NEAREST.
4387 params.filter = VK_FILTER_NEAREST;
4389 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4390 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4392 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4393 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4394 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4396 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4397 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4398 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4401 // Filter is VK_FILTER_LINEAR.
4403 params.filter = VK_FILTER_LINEAR;
4405 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4406 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4408 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4409 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4410 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4412 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4413 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4414 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4419 const std::string description ("Blit without scaling (partial)");
4420 const std::string testName ("without_scaling_partial");
4423 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4424 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4425 params.src.image.extent = defaultExtent;
4426 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4427 params.dst.image.extent = defaultExtent;
4431 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4433 const VkImageBlit imageBlit =
4435 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4437 {defaultSize - defaultFourthSize - i, defaultSize - defaultFourthSize - i, 0},
4438 {defaultSize - i, defaultSize - i, 1}
4439 }, // VkOffset3D srcOffsets[2];
4441 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4444 {i + defaultFourthSize, i + defaultFourthSize, 1}
4445 } // VkOffset3D dstOffset[2];
4447 region.imageBlit = imageBlit;
4448 params.regions.push_back(region);
4452 // Filter is VK_FILTER_NEAREST.
4454 params.filter = VK_FILTER_NEAREST;
4456 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4457 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4460 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4461 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4462 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4464 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4465 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4466 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4469 // Filter is VK_FILTER_LINEAR.
4471 params.filter = VK_FILTER_LINEAR;
4473 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4474 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4476 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4477 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4478 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4480 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4481 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4482 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4487 const std::string description ("Blit with scaling (partial)");
4488 const std::string testName ("scaling_partial");
4490 // Test Color formats.
4493 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4494 params.src.image.extent = defaultExtent;
4495 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4496 params.dst.image.extent = defaultExtent;
4499 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4501 const VkImageBlit imageBlit =
4503 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4506 {defaultSize, defaultSize, 1}
4507 }, // VkOffset3D srcOffsets[2];
4509 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4512 {i + defaultFourthSize / j, defaultFourthSize / j, 1}
4513 } // VkOffset3D dstOffset[2];
4515 region.imageBlit = imageBlit;
4516 params.regions.push_back(region);
4518 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4520 const VkImageBlit imageBlit =
4522 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4525 {i + defaultFourthSize, i + defaultFourthSize, 1}
4526 }, // VkOffset3D srcOffsets[2];
4528 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4530 {i, defaultSize / 2, 0},
4531 {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1}
4532 } // VkOffset3D dstOffset[2];
4534 region.imageBlit = imageBlit;
4535 params.regions.push_back(region);
4538 addBlittingTestsAllFormats(blitImgAllFormatsTests.get(), testCtx, params);
4541 // Test Depth and Stencil formats.
4543 const VkFormat compatibleDepthAndStencilFormats[] =
4545 VK_FORMAT_D16_UNORM,
4546 VK_FORMAT_X8_D24_UNORM_PACK32,
4547 VK_FORMAT_D32_SFLOAT,
4549 VK_FORMAT_D16_UNORM_S8_UINT,
4550 VK_FORMAT_D24_UNORM_S8_UINT,
4551 VK_FORMAT_D32_SFLOAT_S8_UINT,
4554 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(compatibleDepthAndStencilFormats); ++compatibleFormatsIndex)
4558 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4559 params.src.image.extent = defaultExtent;
4560 params.dst.image.extent = defaultExtent;
4561 params.src.image.format = compatibleDepthAndStencilFormats[compatibleFormatsIndex];
4562 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4563 params.dst.image.format = params.src.image.format;
4564 std::ostringstream oss;
4565 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
4567 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
4568 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
4571 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4573 const VkOffset3D srcOffset0 = {0, 0, 0};
4574 const VkOffset3D srcOffset1 = {defaultSize, defaultSize, 1};
4575 const VkOffset3D dstOffset0 = {i, 0, 0};
4576 const VkOffset3D dstOffset1 = {i + defaultFourthSize / j, defaultFourthSize / j, 1};
4578 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4580 const VkImageBlit imageBlit =
4582 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4583 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4584 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4585 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4587 region.imageBlit = imageBlit;
4588 params.regions.push_back(region);
4590 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4592 const VkImageBlit imageBlit =
4594 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4595 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4596 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4597 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4599 region.imageBlit = imageBlit;
4600 params.regions.push_back(region);
4603 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4605 const VkOffset3D srcOffset0 = {i, i, 0};
4606 const VkOffset3D srcOffset1 = {i + defaultFourthSize, i + defaultFourthSize, 1};
4607 const VkOffset3D dstOffset0 = {i, defaultSize / 2, 0};
4608 const VkOffset3D dstOffset1 = {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1};
4610 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4612 const VkImageBlit imageBlit =
4614 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4615 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4616 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4617 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4619 region.imageBlit = imageBlit;
4620 params.regions.push_back(region);
4622 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4624 const VkImageBlit imageBlit =
4626 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4627 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4628 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4629 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4631 region.imageBlit = imageBlit;
4632 params.regions.push_back(region);
4636 params.filter = VK_FILTER_NEAREST;
4637 blitImgAllFormatsTests->addChild(new BlittingTestCase(testCtx, oss.str() + "_nearest", description, params));
4641 blittingImageTests->addChild(blitImgSimpleTests.release());
4642 blittingImageTests->addChild(blitImgAllFormatsTests.release());
4644 // Resolve image to image testcases.
4645 const VkSampleCountFlagBits samples[] =
4647 VK_SAMPLE_COUNT_2_BIT,
4648 VK_SAMPLE_COUNT_4_BIT,
4649 VK_SAMPLE_COUNT_8_BIT,
4650 VK_SAMPLE_COUNT_16_BIT,
4651 VK_SAMPLE_COUNT_32_BIT,
4652 VK_SAMPLE_COUNT_64_BIT
4654 const VkExtent3D resolveExtent = {256u, 256u, 1};
4657 const std::string description ("Resolve from image to image");
4658 const std::string testName ("whole");
4661 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4662 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4663 params.src.image.extent = resolveExtent;
4664 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4665 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4666 params.dst.image.extent = resolveExtent;
4669 const VkImageSubresourceLayers sourceLayer =
4671 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4672 0u, // uint32_t mipLevel;
4673 0u, // uint32_t baseArrayLayer;
4674 1u // uint32_t layerCount;
4676 const VkImageResolve testResolve =
4678 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4679 {0, 0, 0}, // VkOffset3D srcOffset;
4680 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4681 {0, 0, 0}, // VkOffset3D dstOffset;
4682 resolveExtent, // VkExtent3D extent;
4685 CopyRegion imageResolve;
4686 imageResolve.imageResolve = testResolve;
4687 params.regions.push_back(imageResolve);
4690 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4692 params.samples = samples[samplesIndex];
4693 std::ostringstream caseName;
4694 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4695 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4700 const std::string description ("Resolve from image to image");
4701 const std::string testName ("partial");
4704 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4705 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4706 params.src.image.extent = resolveExtent;
4707 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4708 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4709 params.dst.image.extent = resolveExtent;
4712 const VkImageSubresourceLayers sourceLayer =
4714 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4715 0u, // uint32_t mipLevel;
4716 0u, // uint32_t baseArrayLayer;
4717 1u // uint32_t layerCount;
4719 const VkImageResolve testResolve =
4721 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4722 {0, 0, 0}, // VkOffset3D srcOffset;
4723 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4724 {64u, 64u, 0}, // VkOffset3D dstOffset;
4725 {128u, 128u, 1u}, // VkExtent3D extent;
4728 CopyRegion imageResolve;
4729 imageResolve.imageResolve = testResolve;
4730 params.regions.push_back(imageResolve);
4733 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4735 params.samples = samples[samplesIndex];
4736 std::ostringstream caseName;
4737 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4738 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4743 const std::string description ("Resolve from image to image");
4744 const std::string testName ("with_regions");
4747 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4748 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4749 params.src.image.extent = resolveExtent;
4750 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4751 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4752 params.dst.image.extent = resolveExtent;
4755 const VkImageSubresourceLayers sourceLayer =
4757 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4758 0u, // uint32_t mipLevel;
4759 0u, // uint32_t baseArrayLayer;
4760 1u // uint32_t layerCount;
4763 for (int i = 0; i < 256; i += 64)
4765 const VkImageResolve testResolve =
4767 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4768 {i, i, 0}, // VkOffset3D srcOffset;
4769 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4770 {i, 0, 0}, // VkOffset3D dstOffset;
4771 {64u, 64u, 1u}, // VkExtent3D extent;
4774 CopyRegion imageResolve;
4775 imageResolve.imageResolve = testResolve;
4776 params.regions.push_back(imageResolve);
4780 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4782 params.samples = samples[samplesIndex];
4783 std::ostringstream caseName;
4784 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4785 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4790 const std::string description ("Resolve from image to image");
4791 const std::string testName ("whole_copy_before_resolving");
4794 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4795 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4796 params.src.image.extent = defaultExtent;
4797 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4798 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4799 params.dst.image.extent = defaultExtent;
4802 const VkImageSubresourceLayers sourceLayer =
4804 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4805 0u, // uint32_t mipLevel;
4806 0u, // uint32_t baseArrayLayer;
4807 1u // uint32_t layerCount;
4810 const VkImageResolve testResolve =
4812 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4813 {0, 0, 0}, // VkOffset3D srcOffset;
4814 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4815 {0, 0, 0}, // VkOffset3D dstOffset;
4816 defaultExtent, // VkExtent3D extent;
4819 CopyRegion imageResolve;
4820 imageResolve.imageResolve = testResolve;
4821 params.regions.push_back(imageResolve);
4824 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4826 params.samples = samples[samplesIndex];
4827 std::ostringstream caseName;
4828 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4829 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_MS_IMAGE));
4834 const std::string description ("Resolve from image to image");
4835 const std::string testName ("whole_array_image");
4838 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4839 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4840 params.src.image.extent = defaultExtent;
4841 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4842 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4843 params.dst.image.extent = defaultExtent;
4844 params.dst.image.extent.depth = 5u;
4846 for (deUint32 layerNdx=0; layerNdx < params.dst.image.extent.depth; ++layerNdx)
4848 const VkImageSubresourceLayers sourceLayer =
4850 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4851 0u, // uint32_t mipLevel;
4852 layerNdx, // uint32_t baseArrayLayer;
4853 1u // uint32_t layerCount;
4856 const VkImageResolve testResolve =
4858 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4859 {0, 0, 0}, // VkOffset3D srcOffset;
4860 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4861 {0, 0, 0}, // VkOffset3D dstOffset;
4862 defaultExtent, // VkExtent3D extent;
4865 CopyRegion imageResolve;
4866 imageResolve.imageResolve = testResolve;
4867 params.regions.push_back(imageResolve);
4870 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4872 params.samples = samples[samplesIndex];
4873 std::ostringstream caseName;
4874 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4875 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE));
4880 TestParams params3DTo2D;
4881 const deUint32 slicesLayers = 16u;
4882 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
4883 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
4884 params3DTo2D.src.image.extent = defaultHalfExtent;
4885 params3DTo2D.src.image.extent.depth = slicesLayers;
4886 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
4887 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
4888 params3DTo2D.dst.image.extent = defaultHalfExtent;
4889 params3DTo2D.dst.image.extent.depth = slicesLayers;
4891 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
4893 const VkImageSubresourceLayers sourceLayer =
4895 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4896 0u, // uint32_t mipLevel;
4897 0u, // uint32_t baseArrayLayer;
4898 1u // uint32_t layerCount;
4901 const VkImageSubresourceLayers destinationLayer =
4903 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4904 0u, // uint32_t mipLevel;
4905 slicesLayersNdx, // uint32_t baseArrayLayer;
4906 1u // uint32_t layerCount;
4909 const VkImageCopy testCopy =
4911 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4912 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
4913 destinationLayer, // VkImageSubresourceLayers dstSubresource;
4914 {0, 0, 0}, // VkOffset3D dstOffset;
4915 defaultHalfExtent, // VkExtent3D extent;
4918 CopyRegion imageCopy;
4919 imageCopy.imageCopy = testCopy;
4921 params3DTo2D.regions.push_back(imageCopy);
4923 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
4927 TestParams params2DTo3D;
4928 const deUint32 slicesLayers = 16u;
4929 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
4930 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
4931 params2DTo3D.src.image.extent = defaultHalfExtent;
4932 params2DTo3D.src.image.extent.depth = slicesLayers;
4933 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
4934 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
4935 params2DTo3D.dst.image.extent = defaultHalfExtent;
4936 params2DTo3D.dst.image.extent.depth = slicesLayers;
4938 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
4940 const VkImageSubresourceLayers sourceLayer =
4942 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4943 0u, // uint32_t mipLevel;
4944 slicesLayersNdx, // uint32_t baseArrayLayer;
4945 1u // uint32_t layerCount;
4948 const VkImageSubresourceLayers destinationLayer =
4950 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4951 0u, // uint32_t mipLevel;
4952 0u, // uint32_t baseArrayLayer;
4953 1u // uint32_t layerCount;
4956 const VkImageCopy testCopy =
4958 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4959 {0, 0, 0}, // VkOffset3D srcOffset;
4960 destinationLayer, // VkImageSubresourceLayers dstSubresource;
4961 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D dstOffset;
4962 defaultHalfExtent, // VkExtent3D extent;
4965 CopyRegion imageCopy;
4966 imageCopy.imageCopy = testCopy;
4968 params2DTo3D.regions.push_back(imageCopy);
4971 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
4975 TestParams params3DTo2D;
4976 const deUint32 slicesLayers = 16u;
4977 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
4978 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
4979 params3DTo2D.src.image.extent = defaultHalfExtent;
4980 params3DTo2D.src.image.extent.depth = slicesLayers;
4981 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
4982 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
4983 params3DTo2D.dst.image.extent = defaultHalfExtent;
4984 params3DTo2D.dst.image.extent.depth = slicesLayers;
4987 const VkImageSubresourceLayers sourceLayer =
4989 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4990 0u, // uint32_t mipLevel;
4991 0u, // uint32_t baseArrayLayer;
4992 1u // uint32_t layerCount;
4995 const VkImageSubresourceLayers destinationLayer =
4997 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4998 0u, // uint32_t mipLevel;
4999 0, // uint32_t baseArrayLayer;
5000 slicesLayers // uint32_t layerCount;
5003 const VkImageCopy testCopy =
5005 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5006 {0, 0, 0}, // VkOffset3D srcOffset;
5007 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5008 {0, 0, 0}, // VkOffset3D dstOffset;
5009 params3DTo2D.src.image.extent // VkExtent3D extent;
5012 CopyRegion imageCopy;
5013 imageCopy.imageCopy = testCopy;
5015 params3DTo2D.regions.push_back(imageCopy);
5017 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
5021 TestParams params2DTo3D;
5022 const deUint32 slicesLayers = 16u;
5023 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5024 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5025 params2DTo3D.src.image.extent = defaultHalfExtent;
5026 params2DTo3D.src.image.extent.depth = slicesLayers;
5027 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5028 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5029 params2DTo3D.dst.image.extent = defaultHalfExtent;
5030 params2DTo3D.dst.image.extent.depth = slicesLayers;
5033 const VkImageSubresourceLayers sourceLayer =
5035 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5036 0u, // uint32_t mipLevel;
5037 0u, // uint32_t baseArrayLayer;
5038 slicesLayers // uint32_t layerCount;
5041 const VkImageSubresourceLayers destinationLayer =
5043 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5044 0u, // uint32_t mipLevel;
5045 0u, // uint32_t baseArrayLayer;
5046 1u // uint32_t layerCount;
5049 const VkImageCopy testCopy =
5051 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5052 {0, 0, 0}, // VkOffset3D srcOffset;
5053 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5054 {0, 0, 0}, // VkOffset3D dstOffset;
5055 params2DTo3D.dst.image.extent, // VkExtent3D extent;
5058 CopyRegion imageCopy;
5059 imageCopy.imageCopy = testCopy;
5061 params2DTo3D.regions.push_back(imageCopy);
5064 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
5068 TestParams params3DTo2D;
5069 const deUint32 slicesLayers = 16u;
5070 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5071 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5072 params3DTo2D.src.image.extent = defaultHalfExtent;
5073 params3DTo2D.src.image.extent.depth = slicesLayers;
5074 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5075 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5076 params3DTo2D.dst.image.extent = defaultHalfExtent;
5077 params3DTo2D.dst.image.extent.depth = slicesLayers;
5079 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5080 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5082 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5084 const VkImageSubresourceLayers sourceLayer =
5086 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5087 0u, // uint32_t mipLevel;
5088 0u, // uint32_t baseArrayLayer;
5089 1u // uint32_t layerCount;
5092 const VkImageSubresourceLayers destinationLayer =
5094 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5095 0u, // uint32_t mipLevel;
5096 slicesLayersNdx, // uint32_t baseArrayLayer;
5097 1u // uint32_t layerCount;
5101 const VkImageCopy testCopy =
5103 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5104 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
5105 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5106 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D dstOffset;
5108 (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
5109 (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
5111 } // VkExtent3D extent;
5114 CopyRegion imageCopy;
5115 imageCopy.imageCopy = testCopy;
5116 params3DTo2D.regions.push_back(imageCopy);
5118 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
5122 TestParams params2DTo3D;
5123 const deUint32 slicesLayers = 16u;
5124 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5125 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5126 params2DTo3D.src.image.extent = defaultHalfExtent;
5127 params2DTo3D.src.image.extent.depth = slicesLayers;
5128 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5129 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5130 params2DTo3D.dst.image.extent = defaultHalfExtent;
5131 params2DTo3D.dst.image.extent.depth = slicesLayers;
5133 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5134 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5136 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5138 const VkImageSubresourceLayers sourceLayer =
5140 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5141 0u, // uint32_t mipLevel;
5142 slicesLayersNdx, // uint32_t baseArrayLayer;
5143 1u // uint32_t layerCount;
5146 const VkImageSubresourceLayers destinationLayer =
5148 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5149 0u, // uint32_t mipLevel;
5150 0u, // uint32_t baseArrayLayer;
5151 1u // uint32_t layerCount;
5154 const VkImageCopy testCopy =
5156 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5157 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D srcOffset;
5158 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5159 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)(slicesLayersNdx)}, // VkOffset3D dstOffset;
5161 defaultHalfExtent.width - regionWidth*slicesLayersNdx,
5162 defaultHalfExtent.height - regionHeight*slicesLayersNdx,
5164 } // VkExtent3D extent;
5167 CopyRegion imageCopy;
5168 imageCopy.imageCopy = testCopy;
5170 params2DTo3D.regions.push_back(imageCopy);
5173 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
5176 imageToImageTests->addChild(imgToImg3dImagesTests.release());
5178 copiesAndBlittingTests->addChild(imageToImageTests.release());
5179 copiesAndBlittingTests->addChild(imageToBufferTests.release());
5180 copiesAndBlittingTests->addChild(bufferToImageTests.release());
5181 copiesAndBlittingTests->addChild(bufferToBufferTests.release());
5182 copiesAndBlittingTests->addChild(blittingImageTests.release());
5183 copiesAndBlittingTests->addChild(resolveImageTests.release());
5185 return copiesAndBlittingTests.release();