1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 The Khronos Group Inc.
6 * Copyright (c) 2015 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 "deRandom.hpp"
28 #include "deStringUtil.hpp"
29 #include "deUniquePtr.hpp"
30 #include "vkImageUtil.hpp"
31 #include "vkMemUtil.hpp"
32 #include "vktTestCase.hpp"
33 #include "vktTestCaseUtil.hpp"
34 #include "vkQueryUtil.hpp"
35 #include "vkRefUtil.hpp"
36 #include "vkTypeUtil.hpp"
37 #include "tcuImageCompare.hpp"
38 #include "tcuTextureUtil.hpp"
39 #include "tcuVectorType.hpp"
40 #include "tcuTexture.hpp"
55 VkBufferCopy bufferCopy;
56 VkImageCopy imageCopy;
57 VkBufferImageCopy bufferImageCopy;
58 VkImageBlit imageBlit;
76 std::vector<CopyRegion> regions;
79 class CopiesAndBlittingTestInstance : public vkt::TestInstance
82 CopiesAndBlittingTestInstance (Context& context,
83 TestParams testParams);
84 virtual ~CopiesAndBlittingTestInstance (void);
85 virtual tcu::TestStatus iterate (void) = 0;
88 FILL_MODE_SEQUENTIAL = 0,
96 const TestParams m_params;
98 Move<VkCommandPool> m_cmdPool;
99 Move<VkCommandBuffer> m_cmdBuffer;
100 Move<VkFence> m_fence;
101 de::MovePtr<tcu::TextureLevel> m_sourceTextureLevel;
102 de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
103 de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
105 VkCommandBufferBeginInfo m_cmdBufferBeginInfo;
107 void generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_SEQUENTIAL);
108 virtual void generateExpectedResult (void);
109 void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
110 void uploadImage (tcu::ConstPixelBufferAccess imageAccess, const VkImage& image);
111 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
112 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
113 VkImageAspectFlags getAspectFlag (tcu::TextureFormat format);
114 deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
116 return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
119 de::MovePtr<tcu::TextureLevel> readImage (const vk::DeviceInterface& vk,
122 vk::Allocator& allocator,
125 const VkExtent3D imageSize);
128 CopiesAndBlittingTestInstance::~CopiesAndBlittingTestInstance (void)
132 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
133 : vkt::TestInstance (context)
134 , m_params (testParams)
136 const DeviceInterface& vk = context.getDeviceInterface();
137 const VkDevice vkDevice = context.getDevice();
138 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
140 // Create command pool
142 const VkCommandPoolCreateInfo cmdPoolParams =
144 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
145 DE_NULL, // const void* pNext;
146 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, // VkCmdPoolCreateFlags flags;
147 queueFamilyIndex, // deUint32 queueFamilyIndex;
150 m_cmdPool = createCommandPool(vk, vkDevice, &cmdPoolParams);
153 // Create command buffer
155 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
157 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
158 DE_NULL, // const void* pNext;
159 *m_cmdPool, // VkCommandPool commandPool;
160 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
161 1u // deUint32 bufferCount;
164 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
169 const VkFenceCreateInfo fenceParams =
171 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
172 DE_NULL, // const void* pNext;
173 0u // VkFenceCreateFlags flags;
176 m_fence = createFence(vk, vkDevice, &fenceParams);
180 void CopiesAndBlittingTestInstance::generateBuffer(tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
182 de::Random rnd(width ^ height ^ depth);
183 for (int z = 0; z < depth; z++)
185 for (int y = 0; y < height; y++)
187 for (int x = 0; x < width; x++)
191 case FILL_MODE_SEQUENTIAL:
192 buffer.setPixel(tcu::UVec4(x, y, z, 255), x, y, z);
194 case FILL_MODE_WHITE:
195 buffer.setPixel(tcu::UVec4(255, 255, 255, 255), x, y, z);
198 buffer.setPixel(tcu::UVec4(255, 0, 0, 255), x, y, z);
200 case FILL_MODE_RANDOM:
201 buffer.setPixel(tcu::UVec4(rnd.getUint8(), rnd.getUint8(), rnd.getUint8(), 255), x, y, z);
210 void CopiesAndBlittingTestInstance::uploadBuffer(tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
212 const DeviceInterface& vk = m_context.getDeviceInterface();
213 const VkDevice vkDevice = m_context.getDevice();
214 const deUint32 bufferSize = calculateSize(bufferAccess);
217 deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
218 flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
221 void CopiesAndBlittingTestInstance::uploadImage(tcu::ConstPixelBufferAccess imageAccess, const VkImage& image)
223 const DeviceInterface& vk = m_context.getDeviceInterface();
224 const VkDevice vkDevice = m_context.getDevice();
225 const VkQueue queue = m_context.getUniversalQueue();
226 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
227 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
229 Move<VkBuffer> buffer;
230 const deUint32 bufferSize = calculateSize(imageAccess);
231 de::MovePtr<Allocation> bufferAlloc;
232 Move<VkCommandBuffer> cmdBuffer;
235 // Create source buffer
237 const VkBufferCreateInfo bufferParams =
239 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
240 DE_NULL, // const void* pNext;
241 0u, // VkBufferCreateFlags flags;
242 bufferSize, // VkDeviceSize size;
243 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
244 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
245 1u, // deUint32 queueFamilyIndexCount;
246 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
249 buffer = createBuffer(vk, vkDevice, &bufferParams);
250 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
251 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
254 // Create command buffer
256 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
258 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
259 DE_NULL, // const void* pNext;
260 *m_cmdPool, // VkCommandPool commandPool;
261 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
262 1u, // deUint32 bufferCount;
265 cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferAllocateInfo);
270 const VkFenceCreateInfo fenceParams =
272 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
273 DE_NULL, // const void* pNext;
274 0u // VkFenceCreateFlags flags;
277 fence = createFence(vk, vkDevice, &fenceParams);
280 // Barriers for copying buffer to image
281 const VkBufferMemoryBarrier preBufferBarrier =
283 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
284 DE_NULL, // const void* pNext;
285 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
286 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
287 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
288 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
289 *buffer, // VkBuffer buffer;
290 0u, // VkDeviceSize offset;
291 bufferSize // VkDeviceSize size;
294 const VkImageMemoryBarrier preImageBarrier =
296 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
297 DE_NULL, // const void* pNext;
298 0u, // VkAccessFlags srcAccessMask;
299 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
300 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
301 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
302 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
303 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
304 image, // VkImage image;
305 { // VkImageSubresourceRange subresourceRange;
306 getAspectFlag(imageAccess.getFormat()), // VkImageAspect aspect;
307 0u, // deUint32 baseMipLevel;
308 1u, // deUint32 mipLevels;
309 0u, // deUint32 baseArraySlice;
310 1u, // deUint32 arraySize;
314 const VkImageMemoryBarrier postImageBarrier =
316 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
317 DE_NULL, // const void* pNext;
318 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
319 VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask;
320 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
321 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout newLayout;
322 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
323 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
324 image, // VkImage image;
325 { // VkImageSubresourceRange subresourceRange;
326 getAspectFlag(imageAccess.getFormat()), // VkImageAspect aspect;
327 0u, // deUint32 baseMipLevel;
328 1u, // deUint32 mipLevels;
329 0u, // deUint32 baseArraySlice;
330 1u, // deUint32 arraySize;
334 const VkBufferImageCopy copyRegion =
336 0u, // VkDeviceSize bufferOffset;
337 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
338 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
339 { // VkImageSubresourceLayers imageSubresource;
340 getAspectFlag(imageAccess.getFormat()), // VkImageAspect aspect;
341 0u, // deUint32 mipLevel;
342 0u, // deUint32 baseArrayLayer;
343 1u, // deUint32 layerCount;
345 { 0, 0, 0 }, // VkOffset3D imageOffset;
347 (deUint32)imageAccess.getWidth(),
348 (deUint32)imageAccess.getHeight(),
350 } // VkExtent3D imageExtent;
354 deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
355 flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
357 // Copy buffer to image
358 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
360 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
361 DE_NULL, // const void* pNext;
362 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
363 (const VkCommandBufferInheritanceInfo*)DE_NULL,
366 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
367 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
368 vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
369 vk.cmdPipelineBarrier(*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);
370 VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
372 const VkSubmitInfo submitInfo =
374 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
375 DE_NULL, // const void* pNext;
376 0u, // deUint32 waitSemaphoreCount;
377 DE_NULL, // const VkSemaphore* pWaitSemaphores;
378 (const VkPipelineStageFlags*)DE_NULL,
379 1u, // deUint32 commandBufferCount;
380 &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
381 0u, // deUint32 signalSemaphoreCount;
382 DE_NULL // const VkSemaphore* pSignalSemaphores;
385 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
386 VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
389 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult(tcu::ConstPixelBufferAccess result)
391 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
392 const tcu::UVec4 treshold (0, 0, 0, 0);
394 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, treshold, tcu::COMPARE_LOG_RESULT))
395 return tcu::TestStatus::fail("CopiesAndBlitting test");
397 return tcu::TestStatus::pass("CopiesAndBlitting test");
400 void CopiesAndBlittingTestInstance::generateExpectedResult()
402 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
403 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
405 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
406 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
407 for (deUint32 i = 0; i < m_params.regions.size(); i++)
408 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
411 class CopiesAndBlittingTestCase : public vkt::TestCase
414 CopiesAndBlittingTestCase (tcu::TestContext& testCtx,
415 const std::string& name,
416 const std::string& description)
417 : vkt::TestCase (testCtx, name, description)
420 virtual ~CopiesAndBlittingTestCase (void) {}
422 virtual TestInstance* createInstance (Context& context) const = 0;
425 VkImageAspectFlags CopiesAndBlittingTestInstance::getAspectFlag(tcu::TextureFormat format)
427 VkImageAspectFlags aspectFlag = 0;
428 aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
429 aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
432 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
437 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (const vk::DeviceInterface& vk,
440 vk::Allocator& allocator,
443 const VkExtent3D imageSize)
445 Move<VkBuffer> buffer;
446 de::MovePtr<Allocation> bufferAlloc;
447 Move<VkCommandBuffer> cmdBuffer;
449 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
450 const tcu::TextureFormat tcuFormat = mapVkFormat(format);
451 const VkDeviceSize pixelDataSize = imageSize.width * imageSize.height * imageSize.depth * tcu::getPixelSize(tcuFormat);
452 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(tcuFormat, imageSize.width, imageSize.height, imageSize.depth));
454 // Create destination buffer
456 const VkBufferCreateInfo bufferParams =
458 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
459 DE_NULL, // const void* pNext;
460 0u, // VkBufferCreateFlags flags;
461 pixelDataSize, // VkDeviceSize size;
462 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
463 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
464 1u, // deUint32 queueFamilyIndexCount;
465 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
468 buffer = createBuffer(vk, device, &bufferParams);
469 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
470 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
473 // Create command pool and buffer
475 const VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
477 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
478 DE_NULL, // const void* pNext;
479 *m_cmdPool, // VkCommandPool commandPool;
480 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
481 1u // deUint32 bufferCount;
484 cmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo);
489 const VkFenceCreateInfo fenceParams =
491 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
492 DE_NULL, // const void* pNext;
493 0u // VkFenceCreateFlags flags;
496 fence = createFence(vk, device, &fenceParams);
499 // Barriers for copying image to buffer
501 const VkImageMemoryBarrier imageBarrier =
503 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
504 DE_NULL, // const void* pNext;
505 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
506 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
507 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
508 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
509 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
510 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
511 image, // VkImage image;
512 { // VkImageSubresourceRange subresourceRange;
513 getAspectFlag(tcuFormat), // VkImageAspectFlags aspectMask;
514 0u, // deUint32 baseMipLevel;
515 1u, // deUint32 mipLevels;
516 0u, // deUint32 baseArraySlice;
517 1u // deUint32 arraySize;
521 const VkBufferMemoryBarrier bufferBarrier =
523 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
524 DE_NULL, // const void* pNext;
525 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
526 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
527 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
528 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
529 *buffer, // VkBuffer buffer;
530 0u, // VkDeviceSize offset;
531 pixelDataSize // VkDeviceSize size;
534 // Copy image to buffer
536 const VkBufferImageCopy copyRegion =
538 0u, // VkDeviceSize bufferOffset;
539 (deUint32)imageSize.width, // deUint32 bufferRowLength;
540 (deUint32)imageSize.height, // deUint32 bufferImageHeight;
541 { getAspectFlag(tcuFormat), 0u, 0u, 1u }, // VkImageSubresourceLayers imageSubresource;
542 { 0, 0, 0 }, // VkOffset3D imageOffset;
543 imageSize // VkExtent3D imageExtent;
546 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
548 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
549 DE_NULL, // const void* pNext;
550 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
551 (const VkCommandBufferInheritanceInfo*)DE_NULL,
554 VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
555 vk.cmdPipelineBarrier(*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);
556 vk.cmdCopyImageToBuffer(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, ©Region);
557 vk.cmdPipelineBarrier(*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);
558 VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
560 const VkSubmitInfo submitInfo =
562 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
563 DE_NULL, // const void* pNext;
564 0u, // deUint32 waitSemaphoreCount;
565 DE_NULL, // const VkSemaphore* pWaitSemaphores;
566 (const VkPipelineStageFlags*)DE_NULL,
567 1u, // deUint32 commandBufferCount;
568 &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
569 0u, // deUint32 signalSemaphoreCount;
570 DE_NULL // const VkSemaphore* pSignalSemaphores;
573 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
574 VK_CHECK(vk.waitForFences(device, 1, &fence.get(), 0, ~(0ull) /* infinity */));
577 invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
578 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), bufferAlloc->getHostPtr()));
583 // Copy from image to image.
585 class CopyImageToImage : public CopiesAndBlittingTestInstance
588 CopyImageToImage (Context& context,
590 virtual tcu::TestStatus iterate (void);
592 Move<VkImage> m_source;
593 de::MovePtr<Allocation> m_sourceImageAlloc;
594 Move<VkImage> m_destination;
595 de::MovePtr<Allocation> m_destinationImageAlloc;
597 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
600 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
601 : CopiesAndBlittingTestInstance(context, params)
603 const DeviceInterface& vk = context.getDeviceInterface();
604 const VkDevice vkDevice = context.getDevice();
605 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
606 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
608 VkImageFormatProperties properties;
609 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
610 m_params.src.image.format,
612 VK_IMAGE_TILING_OPTIMAL,
613 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
614 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
615 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
616 m_params.dst.image.format,
618 VK_IMAGE_TILING_OPTIMAL,
619 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
620 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
622 TCU_THROW(NotSupportedError, "Format not supported");
625 // Create source image
627 const VkImageCreateInfo sourceImageParams =
629 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
630 DE_NULL, // const void* pNext;
631 0u, // VkImageCreateFlags flags;
632 VK_IMAGE_TYPE_2D, // VkImageType imageType;
633 m_params.src.image.format, // VkFormat format;
634 m_params.src.image.extent, // VkExtent3D extent;
635 1u, // deUint32 mipLevels;
636 1u, // deUint32 arraySize;
637 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
638 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
639 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
640 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
641 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
642 1u, // deUint32 queueFamilyCount;
643 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
644 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
647 m_source = createImage(vk, vkDevice, &sourceImageParams);
648 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
649 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
652 // Create destination image
654 const VkImageCreateInfo destinationImageParams =
656 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
657 DE_NULL, // const void* pNext;
658 0u, // VkImageCreateFlags flags;
659 VK_IMAGE_TYPE_2D, // VkImageType imageType;
660 m_params.dst.image.format, // VkFormat format;
661 m_params.dst.image.extent, // VkExtent3D extent;
662 1u, // deUint32 mipLevels;
663 1u, // deUint32 arraySize;
664 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
665 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
666 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
667 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
668 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
669 1u, // deUint32 queueFamilyCount;
670 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
671 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
674 m_destination = createImage(vk, vkDevice, &destinationImageParams);
675 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
676 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
680 tcu::TestStatus CopyImageToImage::iterate()
682 tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
683 tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
684 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
685 m_params.src.image.extent.width,
686 m_params.src.image.extent.height,
687 m_params.src.image.extent.depth));
688 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);
689 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
690 (int)m_params.dst.image.extent.width,
691 (int)m_params.dst.image.extent.height,
692 (int)m_params.dst.image.extent.depth));
693 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_SEQUENTIAL);
694 generateExpectedResult();
696 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get());
697 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get());
699 const DeviceInterface& vk = m_context.getDeviceInterface();
700 const VkDevice vkDevice = m_context.getDevice();
701 const VkQueue queue = m_context.getUniversalQueue();
702 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
704 VkImageCopy* imageCopies = ((VkImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkImageCopy)));
705 for (deUint32 i = 0; i < m_params.regions.size(); i++)
706 imageCopies[i] = m_params.regions[i].imageCopy;
708 const VkImageMemoryBarrier imageBarriers[] =
712 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
713 DE_NULL, // const void* pNext;
714 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
715 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
716 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout oldLayout;
717 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
718 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
719 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
720 m_source.get(), // VkImage image;
721 { // VkImageSubresourceRange subresourceRange;
722 getAspectFlag(srcTcuFormat), // VkImageAspectFlags aspectMask;
723 0u, // deUint32 baseMipLevel;
724 1u, // deUint32 mipLevels;
725 0u, // deUint32 baseArraySlice;
726 1u // deUint32 arraySize;
731 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
732 DE_NULL, // const void* pNext;
733 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
734 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
735 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout oldLayout;
736 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
737 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
738 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
739 m_destination.get(), // VkImage image;
740 { // VkImageSubresourceRange subresourceRange;
741 getAspectFlag(dstTcuFormat), // VkImageAspectFlags aspectMask;
742 0u, // deUint32 baseMipLevel;
743 1u, // deUint32 mipLevels;
744 0u, // deUint32 baseArraySlice;
745 1u // deUint32 arraySize;
750 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
752 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
753 DE_NULL, // const void* pNext;
754 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
755 (const VkCommandBufferInheritanceInfo*)DE_NULL,
758 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
759 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);
760 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);
761 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
763 const VkSubmitInfo submitInfo =
765 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
766 DE_NULL, // const void* pNext;
767 0u, // deUint32 waitSemaphoreCount;
768 DE_NULL, // const VkSemaphore* pWaitSemaphores;
769 (const VkPipelineStageFlags*)DE_NULL,
770 1u, // deUint32 commandBufferCount;
771 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
772 0u, // deUint32 signalSemaphoreCount;
773 DE_NULL // const VkSemaphore* pSignalSemaphores;
776 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
777 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
778 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
781 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image.format, m_params.dst.image.extent);
783 return checkTestResult(resultTextureLevel->getAccess());
786 void CopyImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
788 VkOffset3D srcOffset = region.imageCopy.srcOffset;
789 VkOffset3D dstOffset = region.imageCopy.dstOffset;
790 VkExtent3D extent = region.imageCopy.extent;
792 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, extent.width, extent.height);
793 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
794 const tcu::PixelBufferAccess dstWithSrcFormat(srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
795 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, extent.width, extent.height);
797 tcu::copy(dstSubRegion, srcSubRegion);
800 class CopyImageToImageTestCase : public vkt::TestCase
803 CopyImageToImageTestCase (tcu::TestContext& testCtx,
804 const std::string& name,
805 const std::string& description,
806 const TestParams params)
807 : vkt::TestCase (testCtx, name, description)
811 virtual ~CopyImageToImageTestCase (void) {}
813 virtual TestInstance* createInstance (Context& context) const
815 return new CopyImageToImage(context, m_params);
821 // Copy from buffer to buffer.
823 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
826 CopyBufferToBuffer (Context& context, TestParams params);
827 virtual tcu::TestStatus iterate (void);
829 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
830 Move<VkBuffer> m_source;
831 de::MovePtr<Allocation> m_sourceBufferAlloc;
832 Move<VkBuffer> m_destination;
833 de::MovePtr<Allocation> m_destinationBufferAlloc;
836 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
837 : CopiesAndBlittingTestInstance (context, params)
839 const DeviceInterface& vk = context.getDeviceInterface();
840 const VkDevice vkDevice = context.getDevice();
841 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
842 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
844 // Create source buffer
846 const VkBufferCreateInfo sourceBufferParams =
848 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
849 DE_NULL, // const void* pNext;
850 0u, // VkBufferCreateFlags flags;
851 m_params.src.buffer.size, // VkDeviceSize size;
852 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
853 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
854 1u, // deUint32 queueFamilyIndexCount;
855 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
858 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
859 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
860 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
863 // Create desctination buffer
865 const VkBufferCreateInfo destinationBufferParams =
867 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
868 DE_NULL, // const void* pNext;
869 0u, // VkBufferCreateFlags flags;
870 m_params.dst.buffer.size, // VkDeviceSize size;
871 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
872 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
873 1u, // deUint32 queueFamilyIndexCount;
874 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
877 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
878 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
879 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
883 tcu::TestStatus CopyBufferToBuffer::iterate()
885 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
886 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
887 generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
889 const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
890 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
891 generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
893 generateExpectedResult();
895 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
896 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
898 const DeviceInterface& vk = m_context.getDeviceInterface();
899 const VkDevice vkDevice = m_context.getDevice();
900 const VkQueue queue = m_context.getUniversalQueue();
902 const VkBufferMemoryBarrier srcBufferBarrier =
904 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
905 DE_NULL, // const void* pNext;
906 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
907 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
908 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
909 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
910 *m_source, // VkBuffer buffer;
911 0u, // VkDeviceSize offset;
912 m_params.src.buffer.size // VkDeviceSize size;
915 const VkBufferMemoryBarrier dstBufferBarrier =
917 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
918 DE_NULL, // const void* pNext;
919 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
920 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
921 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
922 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
923 *m_destination, // VkBuffer buffer;
924 0u, // VkDeviceSize offset;
925 m_params.dst.buffer.size // VkDeviceSize size;
928 VkBufferCopy* bufferCopies = ((VkBufferCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferCopy)));
929 for (deUint32 i = 0; i < m_params.regions.size(); i++)
930 bufferCopies[i] = m_params.regions[i].bufferCopy;
932 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
934 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
935 DE_NULL, // const void* pNext;
936 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
937 (const VkCommandBufferInheritanceInfo*)DE_NULL,
940 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
941 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &srcBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
942 vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), bufferCopies);
943 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);
944 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
946 const VkSubmitInfo submitInfo =
948 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
949 DE_NULL, // const void* pNext;
950 0u, // deUint32 waitSemaphoreCount;
951 DE_NULL, // const VkSemaphore* pWaitSemaphores;
952 (const VkPipelineStageFlags*)DE_NULL,
953 1u, // deUint32 commandBufferCount;
954 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
955 0u, // deUint32 signalSemaphoreCount;
956 DE_NULL // const VkSemaphore* pSignalSemaphores;
959 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
960 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
961 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
964 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
965 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
966 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
967 deFree(bufferCopies);
969 return checkTestResult(resultLevel->getAccess());
972 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
974 deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
975 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
976 (size_t)region.bufferCopy.size);
979 class BufferToBufferTestCase : public vkt::TestCase
982 BufferToBufferTestCase (tcu::TestContext& testCtx,
983 const std::string& name,
984 const std::string& description,
985 const TestParams params)
986 : vkt::TestCase (testCtx, name, description)
989 virtual ~BufferToBufferTestCase (void) {}
991 virtual TestInstance* createInstance (Context& context) const
993 return new CopyBufferToBuffer(context, m_params);
999 // Copy from image to buffer.
1001 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1004 CopyImageToBuffer (Context& context,
1005 TestParams testParams);
1006 virtual ~CopyImageToBuffer (void) {}
1007 virtual tcu::TestStatus iterate (void);
1009 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1011 tcu::TextureFormat m_textureFormat;
1012 VkDeviceSize m_bufferSize;
1014 Move<VkImage> m_source;
1015 de::MovePtr<Allocation> m_sourceImageAlloc;
1016 Move<VkBuffer> m_destination;
1017 de::MovePtr<Allocation> m_destinationBufferAlloc;
1020 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1021 : CopiesAndBlittingTestInstance(context, testParams)
1022 , m_textureFormat(mapVkFormat(testParams.src.image.format))
1023 , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1025 const DeviceInterface& vk = context.getDeviceInterface();
1026 const VkDevice vkDevice = context.getDevice();
1027 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1028 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1030 // Create source image
1032 const VkImageCreateInfo sourceImageParams =
1034 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1035 DE_NULL, // const void* pNext;
1036 0u, // VkImageCreateFlags flags;
1037 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1038 m_params.src.image.format, // VkFormat format;
1039 m_params.src.image.extent, // VkExtent3D extent;
1040 1u, // deUint32 mipLevels;
1041 1u, // deUint32 arraySize;
1042 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1043 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1044 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1045 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1046 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1047 1u, // deUint32 queueFamilyCount;
1048 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1049 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1052 m_source = createImage(vk, vkDevice, &sourceImageParams);
1053 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1054 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1057 // Create destination buffer
1059 const VkBufferCreateInfo destinationBufferParams =
1061 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1062 DE_NULL, // const void* pNext;
1063 0u, // VkBufferCreateFlags flags;
1064 m_bufferSize, // VkDeviceSize size;
1065 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1066 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1067 1u, // deUint32 queueFamilyIndexCount;
1068 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1071 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1072 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1073 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1077 tcu::TestStatus CopyImageToBuffer::iterate()
1079 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1080 m_params.src.image.extent.width,
1081 m_params.src.image.extent.height,
1082 m_params.src.image.extent.depth));
1083 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_RED);
1084 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1085 generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1087 generateExpectedResult();
1089 uploadImage(m_sourceTextureLevel->getAccess(), *m_source);
1090 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1092 const DeviceInterface& vk = m_context.getDeviceInterface();
1093 const VkDevice vkDevice = m_context.getDevice();
1094 const VkQueue queue = m_context.getUniversalQueue();
1096 // Barriers for copying image to buffer
1097 const VkImageMemoryBarrier imageBarrier =
1099 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1100 DE_NULL, // const void* pNext;
1101 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1102 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1103 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout oldLayout;
1104 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1105 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1106 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1107 *m_source, // VkImage image;
1108 { // VkImageSubresourceRange subresourceRange;
1109 getAspectFlag(m_textureFormat), // VkImageAspectFlags aspectMask;
1110 0u, // deUint32 baseMipLevel;
1111 1u, // deUint32 mipLevels;
1112 0u, // deUint32 baseArraySlice;
1113 1u // deUint32 arraySize;
1117 const VkBufferMemoryBarrier bufferBarrier =
1119 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1120 DE_NULL, // const void* pNext;
1121 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1122 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1123 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1124 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1125 *m_destination, // VkBuffer buffer;
1126 0u, // VkDeviceSize offset;
1127 m_bufferSize // VkDeviceSize size;
1130 // Copy from image to buffer
1131 VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
1132 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1133 bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
1135 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1137 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1138 DE_NULL, // const void* pNext;
1139 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1140 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1143 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1144 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
1145 vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), bufferImageCopies);
1146 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1147 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1149 const VkSubmitInfo submitInfo =
1151 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
1152 DE_NULL, // const void* pNext;
1153 0u, // deUint32 waitSemaphoreCount;
1154 DE_NULL, // const VkSemaphore* pWaitSemaphores;
1155 (const VkPipelineStageFlags*)DE_NULL,
1156 1u, // deUint32 commandBufferCount;
1157 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
1158 0u, // deUint32 signalSemaphoreCount;
1159 DE_NULL // const VkSemaphore* pSignalSemaphores;
1162 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
1163 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
1164 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
1167 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1168 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1169 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1170 deFree(bufferImageCopies);
1172 return checkTestResult(resultLevel->getAccess());
1175 class CopyImageToBufferTestCase : public vkt::TestCase
1178 CopyImageToBufferTestCase (tcu::TestContext& testCtx,
1179 const std::string& name,
1180 const std::string& description,
1181 const TestParams params)
1182 : vkt::TestCase (testCtx, name, description)
1186 virtual ~CopyImageToBufferTestCase (void) {}
1188 virtual TestInstance* createInstance (Context& context) const
1190 return new CopyImageToBuffer(context, m_params);
1193 TestParams m_params;
1196 void CopyImageToBuffer::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1198 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1200 rowLength = region.bufferImageCopy.imageExtent.width;
1202 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1204 imageHeight = region.bufferImageCopy.imageExtent.height;
1206 const int texelSize = src.getFormat().getPixelSize();
1207 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1208 const VkOffset3D srcOffset = region.bufferImageCopy.imageOffset;
1209 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1211 for (deUint32 z = 0; z < extent.depth; z++)
1213 for (deUint32 y = 0; y < extent.height; y++)
1215 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1216 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1217 region.bufferImageCopy.imageExtent.width, 1, 1);
1218 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1219 tcu::copy(dstSubRegion, srcSubRegion);
1224 // Copy from buffer to image.
1226 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1229 CopyBufferToImage (Context& context,
1230 TestParams testParams);
1231 virtual ~CopyBufferToImage (void) {}
1232 virtual tcu::TestStatus iterate (void);
1234 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1236 tcu::TextureFormat m_textureFormat;
1237 VkDeviceSize m_bufferSize;
1239 Move<VkBuffer> m_source;
1240 de::MovePtr<Allocation> m_sourceBufferAlloc;
1241 Move<VkImage> m_destination;
1242 de::MovePtr<Allocation> m_destinationImageAlloc;
1245 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1246 : CopiesAndBlittingTestInstance(context, testParams)
1247 , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1248 , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1250 const DeviceInterface& vk = context.getDeviceInterface();
1251 const VkDevice vkDevice = context.getDevice();
1252 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1253 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
1255 // Create source buffer
1257 const VkBufferCreateInfo sourceBufferParams =
1259 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1260 DE_NULL, // const void* pNext;
1261 0u, // VkBufferCreateFlags flags;
1262 m_bufferSize, // VkDeviceSize size;
1263 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1264 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1265 1u, // deUint32 queueFamilyIndexCount;
1266 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1269 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1270 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1271 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1274 // Create destination image
1276 const VkImageCreateInfo destinationImageParams =
1278 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1279 DE_NULL, // const void* pNext;
1280 0u, // VkImageCreateFlags flags;
1281 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1282 m_params.dst.image.format, // VkFormat format;
1283 m_params.dst.image.extent, // VkExtent3D extent;
1284 1u, // deUint32 mipLevels;
1285 1u, // deUint32 arraySize;
1286 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1287 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1288 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1289 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1290 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1291 1u, // deUint32 queueFamilyCount;
1292 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1293 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1296 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1297 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1298 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1302 tcu::TestStatus CopyBufferToImage::iterate()
1304 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1305 generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1306 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1307 m_params.dst.image.extent.width,
1308 m_params.dst.image.extent.height,
1309 m_params.dst.image.extent.depth));
1311 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);
1313 generateExpectedResult();
1315 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1316 uploadImage(m_destinationTextureLevel->getAccess(), *m_destination);
1318 const DeviceInterface& vk = m_context.getDeviceInterface();
1319 const VkDevice vkDevice = m_context.getDevice();
1320 const VkQueue queue = m_context.getUniversalQueue();
1321 SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
1323 const VkImageMemoryBarrier imageBarrier =
1325 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1326 DE_NULL, // const void* pNext;
1327 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1328 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1329 VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout oldLayout;
1330 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1331 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1332 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1333 *m_destination, // VkImage image;
1334 { // VkImageSubresourceRange subresourceRange;
1335 getAspectFlag(m_textureFormat), // VkImageAspectFlags aspectMask;
1336 0u, // deUint32 baseMipLevel;
1337 1u, // deUint32 mipLevels;
1338 0u, // deUint32 baseArraySlice;
1339 1u // deUint32 arraySize;
1343 // Copy from buffer to image
1344 VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
1345 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1346 bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
1348 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1350 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1351 DE_NULL, // const void* pNext;
1352 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1353 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1356 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1357 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);
1358 vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies);
1359 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1361 const VkSubmitInfo submitInfo =
1363 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
1364 DE_NULL, // const void* pNext;
1365 0u, // deUint32 waitSemaphoreCount;
1366 DE_NULL, // const VkSemaphore* pWaitSemaphores;
1367 (const VkPipelineStageFlags*)DE_NULL,
1368 1u, // deUint32 commandBufferCount;
1369 &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
1370 0u, // deUint32 signalSemaphoreCount;
1371 DE_NULL // const VkSemaphore* pSignalSemaphores;
1374 VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
1375 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
1376 VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
1378 de::MovePtr<tcu::TextureLevel> resultLevel = readImage(vk, vkDevice, queue, memAlloc, *m_destination, m_params.dst.image.format, m_params.dst.image.extent);
1379 deFree(bufferImageCopies);
1381 return checkTestResult(resultLevel->getAccess());
1384 class CopyBufferToImageTestCase : public vkt::TestCase
1387 CopyBufferToImageTestCase (tcu::TestContext& testCtx,
1388 const std::string& name,
1389 const std::string& description,
1390 const TestParams params)
1391 : vkt::TestCase (testCtx, name, description)
1395 virtual ~CopyBufferToImageTestCase (void) {}
1397 virtual TestInstance* createInstance (Context& context) const
1399 return new CopyBufferToImage(context, m_params);
1402 TestParams m_params;
1405 void CopyBufferToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1407 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1409 rowLength = region.bufferImageCopy.imageExtent.width;
1411 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1413 imageHeight = region.bufferImageCopy.imageExtent.height;
1415 const int texelSize = dst.getFormat().getPixelSize();
1416 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1417 const VkOffset3D dstOffset = region.bufferImageCopy.imageOffset;
1418 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1420 for (deUint32 z = 0; z < extent.depth; z++)
1422 for (deUint32 y = 0; y < extent.height; y++)
1424 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1425 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1426 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1427 region.bufferImageCopy.imageExtent.width, 1, 1);
1428 tcu::copy(dstSubRegion, srcSubRegion);
1435 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
1437 de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
1439 const VkExtent3D defaultExtent = {256, 256, 1};
1440 const VkImageSubresourceLayers defaultSourceLayer =
1442 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1443 0u, // uint32_t mipLevel;
1444 0u, // uint32_t baseArrayLayer;
1445 1u, // uint32_t layerCount;
1449 std::ostringstream description;
1450 description << "Copy from image to image";
1453 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1454 params.src.image.extent = defaultExtent;
1455 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1456 params.dst.image.extent = defaultExtent;
1459 const VkImageSubresourceLayers sourceLayer =
1461 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1462 0u, // uint32_t mipLevel;
1463 0u, // uint32_t baseArrayLayer;
1464 1u // uint32_t layerCount;
1466 const VkImageCopy testCopy =
1468 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1469 {0, 0, 0}, // VkOffset3D srcOffset;
1470 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1471 {0, 0, 0}, // VkOffset3D dstOffset;
1472 {256, 256, 1}, // VkExtent3D extent;
1475 CopyRegion imageCopy;
1476 imageCopy.imageCopy = testCopy;
1478 params.regions.push_back(imageCopy);
1481 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "imageToImage_whole", description.str(), params));
1485 std::ostringstream description;
1486 description << "Copy from image to image";
1489 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1490 params.src.image.extent = defaultExtent;
1491 params.dst.image.format = VK_FORMAT_R32_UINT;
1492 params.dst.image.extent = defaultExtent;
1495 const VkImageSubresourceLayers sourceLayer =
1497 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1498 0u, // uint32_t mipLevel;
1499 0u, // uint32_t baseArrayLayer;
1500 1u // uint32_t layerCount;
1502 const VkImageCopy testCopy =
1504 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1505 {0, 0, 0}, // VkOffset3D srcOffset;
1506 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1507 {0, 0, 0}, // VkOffset3D dstOffset;
1508 {256, 256, 1}, // VkExtent3D extent;
1511 CopyRegion imageCopy;
1512 imageCopy.imageCopy = testCopy;
1514 params.regions.push_back(imageCopy);
1517 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_whole_different_format_uncompressed", description.str(), params));
1521 std::ostringstream description;
1522 description << "Copy from image to image";
1525 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1526 params.src.image.extent = defaultExtent;
1527 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1528 params.dst.image.extent = defaultExtent;
1531 const VkImageSubresourceLayers sourceLayer =
1533 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1534 0u, // uint32_t mipLevel;
1535 0u, // uint32_t baseArrayLayer;
1536 1u // uint32_t layerCount;
1538 const VkImageCopy testCopy =
1540 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1541 {0, 0, 0}, // VkOffset3D srcOffset;
1542 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1543 {64, 98, 0}, // VkOffset3D dstOffset;
1544 {16, 16, 1}, // VkExtent3D extent;
1547 CopyRegion imageCopy;
1548 imageCopy.imageCopy = testCopy;
1550 params.regions.push_back(imageCopy);
1553 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_partial", description.str(), params));
1557 std::ostringstream description;
1558 description << "Copy from image to image";
1561 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1562 params.src.image.extent = defaultExtent;
1563 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1564 params.dst.image.extent = defaultExtent;
1566 for (deInt32 i = 0; i < 16; i++)
1568 const VkImageSubresourceLayers sourceLayer =
1570 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
1571 0u, // uint32_t mipLevel;
1572 0u, // uint32_t baseArrayLayer;
1573 1u // uint32_t layerCount;
1575 const VkImageCopy testCopy =
1577 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1578 {0, 0, 0}, // VkOffset3D srcOffset;
1579 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1580 {i*16, 240-i*16, 0}, // VkOffset3D dstOffset;
1581 {16, 16, 1}, // VkExtent3D extent;
1584 CopyRegion imageCopy;
1585 imageCopy.imageCopy = testCopy;
1587 params.regions.push_back(imageCopy);
1590 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_partial_multiple", description.str(), params));
1593 // Copy image to buffer testcases.
1595 std::ostringstream description;
1596 description << "Copy from image to buffer";
1599 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
1600 params.src.image.extent = defaultExtent;
1601 params.dst.buffer.size = 256 * 256;
1603 const VkBufferImageCopy bufferImageCopy =
1605 0u, // VkDeviceSize bufferOffset;
1606 0u, // uint32_t bufferRowLength;
1607 0u, // uint32_t bufferImageHeight;
1608 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
1609 {0, 0, 0}, // VkOffset3D imageOffset;
1610 {16, 16, 1} // VkExtent3D imageExtent;
1612 CopyRegion copyRegion;
1613 copyRegion.bufferImageCopy = bufferImageCopy;
1615 params.regions.push_back(copyRegion);
1617 copiesAndBlittingTests->addChild(new CopyImageToBufferTestCase(testCtx, "image_to_buffer", description.str(), params));
1620 // Copy buffer to image testcases.
1622 std::ostringstream description;
1623 description << "Copy from buffer to image";
1626 params.src.buffer.size = 256 * 256;
1627 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
1628 params.dst.image.extent = defaultExtent;
1630 const VkBufferImageCopy bufferImageCopy =
1632 0u, // VkDeviceSize bufferOffset;
1633 0u, // uint32_t bufferRowLength;
1634 0u, // uint32_t bufferImageHeight;
1635 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
1636 {0, 0, 0}, // VkOffset3D imageOffset;
1637 {16, 16, 1} // VkExtent3D imageExtent;
1639 CopyRegion copyRegion;
1640 copyRegion.bufferImageCopy = bufferImageCopy;
1642 params.regions.push_back(copyRegion);
1644 copiesAndBlittingTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_to_image", description.str(), params));
1648 std::ostringstream description;
1649 description << "Copy from buffer to buffer: whole buffer.";
1652 params.src.buffer.size = 256;
1653 params.dst.buffer.size = 256;
1654 const VkBufferCopy bufferCopy = {
1655 0u, // VkDeviceSize srcOffset;
1656 0u, // VkDeviceSize dstOffset;
1657 256u, // VkDeviceSize size;
1659 CopyRegion copyRegion;
1660 copyRegion.bufferCopy = bufferCopy;
1662 params.regions.push_back(copyRegion);
1664 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_whole", description.str(), params));
1668 std::ostringstream description;
1669 description << "Copy from buffer to buffer: small area.";
1672 params.src.buffer.size = 16;
1673 params.dst.buffer.size = 16;
1674 const VkBufferCopy bufferCopy = {
1675 12u, // VkDeviceSize srcOffset;
1676 4u, // VkDeviceSize dstOffset;
1677 1u, // VkDeviceSize size;
1679 CopyRegion copyRegion;
1680 copyRegion.bufferCopy = bufferCopy;
1682 params.regions.push_back(copyRegion);
1684 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_small", description.str(), params));
1688 std::ostringstream description;
1689 description << "Copy from buffer to buffer: more regions.";
1691 const deUint32 size = 16;
1694 params.src.buffer.size = size;
1695 params.dst.buffer.size = size * (size + 1);
1697 // Copy region with size 1..size
1698 for (unsigned int i = 1; i <= size; i++)
1700 const VkBufferCopy bufferCopy = {
1701 0, // VkDeviceSize srcOffset;
1702 i*size, // VkDeviceSize dstOffset;
1703 i, // VkDeviceSize size;
1705 CopyRegion copyRegion;
1706 copyRegion.bufferCopy = bufferCopy;
1707 params.regions.push_back(copyRegion);
1709 copiesAndBlittingTests->addChild(new BufferToBufferTestCase(testCtx, "buffer_to_buffer_regions", description.str(), params));
1713 std::ostringstream description;
1714 description << "Copy from image to image depth";
1717 params.src.image.format = VK_FORMAT_D32_SFLOAT;
1718 params.src.image.extent = defaultExtent;
1719 params.dst.image.format = VK_FORMAT_D32_SFLOAT;
1720 params.dst.image.extent = defaultExtent;
1723 const VkImageSubresourceLayers sourceLayer =
1725 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
1726 0u, // uint32_t mipLevel;
1727 0u, // uint32_t baseArrayLayer;
1728 1u // uint32_t layerCount;
1730 const VkImageCopy testCopy =
1732 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1733 {0, 0, 0}, // VkOffset3D srcOffset;
1734 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1735 {64, 98, 0}, // VkOffset3D dstOffset;
1736 {16, 16, 1}, // VkExtent3D extent;
1739 CopyRegion imageCopy;
1740 imageCopy.imageCopy = testCopy;
1742 params.regions.push_back(imageCopy);
1745 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_depth", description.str(), params));
1749 std::ostringstream description;
1750 description << "Copy from image to image stencil";
1753 params.src.image.format = VK_FORMAT_S8_UINT;
1754 params.src.image.extent = defaultExtent;
1755 params.dst.image.format = VK_FORMAT_S8_UINT;
1756 params.dst.image.extent = defaultExtent;
1759 const VkImageSubresourceLayers sourceLayer =
1761 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
1762 0u, // uint32_t mipLevel;
1763 0u, // uint32_t baseArrayLayer;
1764 1u // uint32_t layerCount;
1766 const VkImageCopy testCopy =
1768 sourceLayer, // VkImageSubresourceLayers srcSubresource;
1769 {0, 0, 0}, // VkOffset3D srcOffset;
1770 sourceLayer, // VkImageSubresourceLayers dstSubresource;
1771 {64, 98, 0}, // VkOffset3D dstOffset;
1772 {16, 16, 1}, // VkExtent3D extent;
1775 CopyRegion imageCopy;
1776 imageCopy.imageCopy = testCopy;
1778 params.regions.push_back(imageCopy);
1781 copiesAndBlittingTests->addChild(new CopyImageToImageTestCase(testCtx, "image_to_image_stencil", description.str(), params));
1784 return copiesAndBlittingTests.release();