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"
35 #include "tcuTestLog.hpp"
37 #include "vkImageUtil.hpp"
38 #include "vkMemUtil.hpp"
39 #include "vkPrograms.hpp"
40 #include "vkQueryUtil.hpp"
41 #include "vkRefUtil.hpp"
42 #include "vktTestCase.hpp"
43 #include "vktTestCaseUtil.hpp"
44 #include "vkTypeUtil.hpp"
57 MIRROR_MODE_X = (1<<0),
58 MIRROR_MODE_Y = (1<<1),
59 MIRROR_MODE_XY = MIRROR_MODE_X | MIRROR_MODE_Y,
71 VkImageAspectFlags getAspectFlags (tcu::TextureFormat format)
73 VkImageAspectFlags aspectFlag = 0;
74 aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
75 aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
78 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
83 // This is effectively same as vk::isFloatFormat(mapTextureFormat(format))
84 // except that it supports some formats that are not mappable to VkFormat.
85 // When we are checking combined depth and stencil formats, each aspect is
86 // checked separately, and in some cases we construct PBA with a format that
87 // is not mappable to VkFormat.
88 bool isFloatFormat (tcu::TextureFormat format)
90 return tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
95 VkBufferCopy bufferCopy;
96 VkImageCopy imageCopy;
97 VkBufferImageCopy bufferImageCopy;
98 VkImageBlit imageBlit;
99 VkImageResolve imageResolve;
104 VkImageType imageType;
121 std::vector<CopyRegion> regions;
126 VkSampleCountFlagBits samples;
130 inline deUint32 getArraySize(const ImageParms& parms)
132 return (parms.imageType == VK_IMAGE_TYPE_2D) ? parms.extent.depth : 1u;
135 inline VkExtent3D getExtent3D(const ImageParms& parms)
137 const VkExtent3D extent =
141 (parms.imageType == VK_IMAGE_TYPE_2D) ? 1u : parms.extent.depth
146 const tcu::TextureFormat mapCombinedToDepthTransferFormat (const tcu::TextureFormat& combinedFormat)
148 tcu::TextureFormat format;
149 switch (combinedFormat.type)
151 case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
152 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
154 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
155 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNSIGNED_INT_24_8_REV);
157 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
158 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
167 class CopiesAndBlittingTestInstance : public vkt::TestInstance
170 CopiesAndBlittingTestInstance (Context& context,
171 TestParams testParams);
172 virtual tcu::TestStatus iterate (void) = 0;
176 FILL_MODE_GRADIENT = 0,
179 FILL_MODE_MULTISAMPLE,
185 const TestParams m_params;
187 Move<VkCommandPool> m_cmdPool;
188 Move<VkCommandBuffer> m_cmdBuffer;
189 Move<VkFence> m_fence;
190 de::MovePtr<tcu::TextureLevel> m_sourceTextureLevel;
191 de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
192 de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
194 VkCommandBufferBeginInfo m_cmdBufferBeginInfo;
196 void generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_GRADIENT);
197 virtual void generateExpectedResult (void);
198 void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
199 void uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms);
200 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
201 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
202 deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
204 return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
207 de::MovePtr<tcu::TextureLevel> readImage (vk::VkImage image,
208 const ImageParms& imageParms);
209 void submitCommandsAndWait (const DeviceInterface& vk,
210 const VkDevice device,
212 const VkCommandBuffer& cmdBuffer);
215 void uploadImageAspect (const tcu::ConstPixelBufferAccess& src,
217 const ImageParms& parms);
218 void readImageAspect (vk::VkImage src,
219 const tcu::PixelBufferAccess& dst,
220 const ImageParms& parms);
223 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
224 : vkt::TestInstance (context)
225 , m_params (testParams)
227 const DeviceInterface& vk = context.getDeviceInterface();
228 const VkDevice vkDevice = context.getDevice();
229 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
231 // Create command pool
232 m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
234 // Create command buffer
235 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
238 m_fence = createFence(vk, vkDevice);
241 void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
243 if (mode == FILL_MODE_GRADIENT)
245 tcu::fillWithComponentGradients(buffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
249 const tcu::Vec4 redColor (1.0, 0.0, 0.0, 1.0);
250 const tcu::Vec4 greenColor (0.0, 1.0, 0.0, 1.0);
251 const tcu::Vec4 blueColor (0.0, 0.0, 1.0, 1.0);
252 const tcu::Vec4 whiteColor (1.0, 1.0, 1.0, 1.0);
254 for (int z = 0; z < depth; z++)
256 for (int y = 0; y < height; y++)
258 for (int x = 0; x < width; x++)
262 case FILL_MODE_WHITE:
263 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
265 buffer.setPixDepth(1.0f, x, y, z);
266 if (tcu::hasStencilComponent(buffer.getFormat().order))
267 buffer.setPixStencil(255, x, y, z);
270 buffer.setPixel(whiteColor, x, y, z);
273 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
275 buffer.setPixDepth(redColor[x % 4], x, y, z);
276 if (tcu::hasStencilComponent(buffer.getFormat().order))
277 buffer.setPixStencil(255 * (int)redColor[y % 4], x, y, z);
280 buffer.setPixel(redColor, x, y, z);
282 case FILL_MODE_MULTISAMPLE:
283 buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
293 void CopiesAndBlittingTestInstance::uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
295 const DeviceInterface& vk = m_context.getDeviceInterface();
296 const VkDevice vkDevice = m_context.getDevice();
297 const deUint32 bufferSize = calculateSize(bufferAccess);
300 deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
301 flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
304 void CopiesAndBlittingTestInstance::uploadImageAspect (const tcu::ConstPixelBufferAccess& imageAccess, const VkImage& image, const ImageParms& parms)
306 const DeviceInterface& vk = m_context.getDeviceInterface();
307 const VkDevice vkDevice = m_context.getDevice();
308 const VkQueue queue = m_context.getUniversalQueue();
309 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
310 Allocator& memAlloc = m_context.getDefaultAllocator();
311 Move<VkBuffer> buffer;
312 const deUint32 bufferSize = calculateSize(imageAccess);
313 de::MovePtr<Allocation> bufferAlloc;
314 const deUint32 arraySize = getArraySize(parms);
315 const VkExtent3D imageExtent = getExtent3D(parms);
317 // Create source buffer
319 const VkBufferCreateInfo bufferParams =
321 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
322 DE_NULL, // const void* pNext;
323 0u, // VkBufferCreateFlags flags;
324 bufferSize, // VkDeviceSize size;
325 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
326 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
327 1u, // deUint32 queueFamilyIndexCount;
328 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
331 buffer = createBuffer(vk, vkDevice, &bufferParams);
332 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
333 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
336 // Barriers for copying buffer to image
337 const VkBufferMemoryBarrier preBufferBarrier =
339 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
340 DE_NULL, // const void* pNext;
341 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
342 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
343 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
344 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
345 *buffer, // VkBuffer buffer;
346 0u, // VkDeviceSize offset;
347 bufferSize // VkDeviceSize size;
350 const VkImageAspectFlags formatAspect = getAspectFlags(mapVkFormat(parms.format));
351 const bool skipPreImageBarrier = formatAspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) &&
352 getAspectFlags(imageAccess.getFormat()) == VK_IMAGE_ASPECT_STENCIL_BIT;
353 const VkImageMemoryBarrier preImageBarrier =
355 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
356 DE_NULL, // const void* pNext;
357 0u, // VkAccessFlags srcAccessMask;
358 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
359 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
360 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
361 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
362 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
363 image, // VkImage image;
364 { // VkImageSubresourceRange subresourceRange;
365 formatAspect, // VkImageAspectFlags aspect;
366 0u, // deUint32 baseMipLevel;
367 1u, // deUint32 mipLevels;
368 0u, // deUint32 baseArraySlice;
369 arraySize, // deUint32 arraySize;
373 const VkImageMemoryBarrier postImageBarrier =
375 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
376 DE_NULL, // const void* pNext;
377 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
378 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
379 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
380 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
381 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
382 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
383 image, // VkImage image;
384 { // VkImageSubresourceRange subresourceRange;
385 formatAspect, // VkImageAspectFlags aspect;
386 0u, // deUint32 baseMipLevel;
387 1u, // deUint32 mipLevels;
388 0u, // deUint32 baseArraySlice;
389 arraySize, // deUint32 arraySize;
393 const VkBufferImageCopy copyRegion =
395 0u, // VkDeviceSize bufferOffset;
396 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
397 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
399 getAspectFlags(imageAccess.getFormat()), // VkImageAspectFlags aspect;
400 0u, // deUint32 mipLevel;
401 0u, // deUint32 baseArrayLayer;
402 arraySize, // deUint32 layerCount;
403 }, // VkImageSubresourceLayers imageSubresource;
404 { 0, 0, 0 }, // VkOffset3D imageOffset;
405 imageExtent // VkExtent3D imageExtent;
409 deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
410 flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
412 // Copy buffer to image
413 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
415 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
416 DE_NULL, // const void* pNext;
417 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
418 (const VkCommandBufferInheritanceInfo*)DE_NULL,
421 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
422 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL,
423 1, &preBufferBarrier, (skipPreImageBarrier ? 0 : 1), (skipPreImageBarrier ? DE_NULL : &preImageBarrier));
424 vk.cmdCopyBufferToImage(*m_cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
425 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);
426 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
428 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
431 void CopiesAndBlittingTestInstance::uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms)
433 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
435 if (tcu::hasDepthComponent(src.getFormat().order))
437 tcu::TextureLevel depthTexture (mapCombinedToDepthTransferFormat(src.getFormat()), src.getWidth(), src.getHeight(), src.getDepth());
438 tcu::copy(depthTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH));
439 uploadImageAspect(depthTexture.getAccess(), dst, parms);
442 if (tcu::hasStencilComponent(src.getFormat().order))
444 tcu::TextureLevel stencilTexture (tcu::getEffectiveDepthStencilTextureFormat(src.getFormat(), tcu::Sampler::MODE_STENCIL), src.getWidth(), src.getHeight(), src.getDepth());
445 tcu::copy(stencilTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL));
446 uploadImageAspect(stencilTexture.getAccess(), dst, parms);
450 uploadImageAspect(src, dst, parms);
453 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult (tcu::ConstPixelBufferAccess result)
455 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
457 if (isFloatFormat(result.getFormat()))
459 const tcu::Vec4 threshold (0.0f);
460 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
461 return tcu::TestStatus::fail("CopiesAndBlitting test");
465 const tcu::UVec4 threshold (0u);
466 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
467 return tcu::TestStatus::fail("CopiesAndBlitting test");
470 return tcu::TestStatus::pass("CopiesAndBlitting test");
473 void CopiesAndBlittingTestInstance::generateExpectedResult (void)
475 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
476 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
478 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
479 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
481 for (deUint32 i = 0; i < m_params.regions.size(); i++)
482 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
485 class CopiesAndBlittingTestCase : public vkt::TestCase
488 CopiesAndBlittingTestCase (tcu::TestContext& testCtx,
489 const std::string& name,
490 const std::string& description)
491 : vkt::TestCase (testCtx, name, description)
494 virtual TestInstance* createInstance (Context& context) const = 0;
497 void CopiesAndBlittingTestInstance::readImageAspect (vk::VkImage image,
498 const tcu::PixelBufferAccess& dst,
499 const ImageParms& imageParms)
501 const DeviceInterface& vk = m_context.getDeviceInterface();
502 const VkDevice device = m_context.getDevice();
503 const VkQueue queue = m_context.getUniversalQueue();
504 Allocator& allocator = m_context.getDefaultAllocator();
506 Move<VkBuffer> buffer;
507 de::MovePtr<Allocation> bufferAlloc;
508 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
509 const VkDeviceSize pixelDataSize = calculateSize(dst);
510 const VkExtent3D imageExtent = getExtent3D(imageParms);
512 // Create destination buffer
514 const VkBufferCreateInfo bufferParams =
516 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
517 DE_NULL, // const void* pNext;
518 0u, // VkBufferCreateFlags flags;
519 pixelDataSize, // VkDeviceSize size;
520 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
521 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
522 1u, // deUint32 queueFamilyIndexCount;
523 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
526 buffer = createBuffer(vk, device, &bufferParams);
527 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
528 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
530 deMemset(bufferAlloc->getHostPtr(), 0, static_cast<size_t>(pixelDataSize));
531 flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
534 // Barriers for copying image to buffer
535 const VkImageAspectFlags formatAspect = getAspectFlags(mapVkFormat(imageParms.format));
536 const VkImageMemoryBarrier imageBarrier =
538 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
539 DE_NULL, // const void* pNext;
540 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
541 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
542 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
543 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
544 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
545 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
546 image, // VkImage image;
547 { // VkImageSubresourceRange subresourceRange;
548 formatAspect, // VkImageAspectFlags aspectMask;
549 0u, // deUint32 baseMipLevel;
550 1u, // deUint32 mipLevels;
551 0u, // deUint32 baseArraySlice;
552 getArraySize(imageParms)// deUint32 arraySize;
556 const VkBufferMemoryBarrier bufferBarrier =
558 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
559 DE_NULL, // const void* pNext;
560 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
561 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
562 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
563 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
564 *buffer, // VkBuffer buffer;
565 0u, // VkDeviceSize offset;
566 pixelDataSize // VkDeviceSize size;
569 const VkImageMemoryBarrier postImageBarrier =
571 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
572 DE_NULL, // const void* pNext;
573 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags srcAccessMask;
574 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
575 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout oldLayout;
576 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
577 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
578 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
579 image, // VkImage image;
581 formatAspect, // VkImageAspectFlags aspectMask;
582 0u, // deUint32 baseMipLevel;
583 1u, // deUint32 mipLevels;
584 0u, // deUint32 baseArraySlice;
585 getArraySize(imageParms) // deUint32 arraySize;
586 } // VkImageSubresourceRange subresourceRange;
589 // Copy image to buffer
590 const VkImageAspectFlags aspect = getAspectFlags(dst.getFormat());
591 const VkBufferImageCopy copyRegion =
593 0u, // VkDeviceSize bufferOffset;
594 (deUint32)dst.getWidth(), // deUint32 bufferRowLength;
595 (deUint32)dst.getHeight(), // deUint32 bufferImageHeight;
597 aspect, // VkImageAspectFlags aspect;
598 0u, // deUint32 mipLevel;
599 0u, // deUint32 baseArrayLayer;
600 getArraySize(imageParms), // deUint32 layerCount;
601 }, // VkImageSubresourceLayers imageSubresource;
602 { 0, 0, 0 }, // VkOffset3D imageOffset;
603 imageExtent // VkExtent3D imageExtent;
606 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
608 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
609 DE_NULL, // const void* pNext;
610 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
611 (const VkCommandBufferInheritanceInfo*)DE_NULL,
614 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
615 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);
616 vk.cmdCopyImageToBuffer(*m_cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, ©Region);
617 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 1, &postImageBarrier);
618 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
620 submitCommandsAndWait(vk, device, queue, *m_cmdBuffer);
623 invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
624 tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferAlloc->getHostPtr()));
627 void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
629 const VkSubmitInfo submitInfo =
631 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
632 DE_NULL, // const void* pNext;
633 0u, // deUint32 waitSemaphoreCount;
634 DE_NULL, // const VkSemaphore* pWaitSemaphores;
635 (const VkPipelineStageFlags*)DE_NULL,
636 1u, // deUint32 commandBufferCount;
637 &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
638 0u, // deUint32 signalSemaphoreCount;
639 DE_NULL // const VkSemaphore* pSignalSemaphores;
642 VK_CHECK(vk.resetFences(device, 1, &m_fence.get()));
643 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
644 VK_CHECK(vk.waitForFences(device, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
647 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (vk::VkImage image,
648 const ImageParms& parms)
650 const tcu::TextureFormat imageFormat = mapVkFormat(parms.format);
651 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(imageFormat, parms.extent.width, parms.extent.height, parms.extent.depth));
653 if (tcu::isCombinedDepthStencilType(imageFormat.type))
655 if (tcu::hasDepthComponent(imageFormat.order))
657 tcu::TextureLevel depthTexture (mapCombinedToDepthTransferFormat(imageFormat), parms.extent.width, parms.extent.height, parms.extent.depth);
658 readImageAspect(image, depthTexture.getAccess(), parms);
659 tcu::copy(tcu::getEffectiveDepthStencilAccess(resultLevel->getAccess(), tcu::Sampler::MODE_DEPTH), depthTexture.getAccess());
662 if (tcu::hasStencilComponent(imageFormat.order))
664 tcu::TextureLevel stencilTexture (tcu::getEffectiveDepthStencilTextureFormat(imageFormat, tcu::Sampler::MODE_STENCIL), parms.extent.width, parms.extent.height, parms.extent.depth);
665 readImageAspect(image, stencilTexture.getAccess(), parms);
666 tcu::copy(tcu::getEffectiveDepthStencilAccess(resultLevel->getAccess(), tcu::Sampler::MODE_STENCIL), stencilTexture.getAccess());
670 readImageAspect(image, resultLevel->getAccess(), parms);
675 // Copy from image to image.
677 class CopyImageToImage : public CopiesAndBlittingTestInstance
680 CopyImageToImage (Context& context,
682 virtual tcu::TestStatus iterate (void);
685 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
688 Move<VkImage> m_source;
689 de::MovePtr<Allocation> m_sourceImageAlloc;
690 Move<VkImage> m_destination;
691 de::MovePtr<Allocation> m_destinationImageAlloc;
693 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
696 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
697 : CopiesAndBlittingTestInstance(context, params)
699 const DeviceInterface& vk = context.getDeviceInterface();
700 const VkDevice vkDevice = context.getDevice();
701 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
702 Allocator& memAlloc = context.getDefaultAllocator();
704 if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
705 (m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
707 if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1") == context.getDeviceExtensions().end())
708 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
711 VkImageFormatProperties properties;
712 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
713 m_params.src.image.format,
714 m_params.src.image.imageType,
715 VK_IMAGE_TILING_OPTIMAL,
716 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
718 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
719 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
720 m_params.dst.image.format,
721 m_params.dst.image.imageType,
722 VK_IMAGE_TILING_OPTIMAL,
723 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
725 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
727 TCU_THROW(NotSupportedError, "Format not supported");
730 // Create source image
732 const VkImageCreateInfo sourceImageParams =
734 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
735 DE_NULL, // const void* pNext;
736 0u, // VkImageCreateFlags flags;
737 m_params.src.image.imageType, // VkImageType imageType;
738 m_params.src.image.format, // VkFormat format;
739 getExtent3D(m_params.src.image), // VkExtent3D extent;
740 1u, // deUint32 mipLevels;
741 getArraySize(m_params.src.image), // deUint32 arraySize;
742 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
743 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
744 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
745 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
746 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
747 1u, // deUint32 queueFamilyCount;
748 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
749 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
752 m_source = createImage(vk, vkDevice, &sourceImageParams);
753 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
754 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
757 // Create destination image
759 const VkImageCreateInfo destinationImageParams =
761 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
762 DE_NULL, // const void* pNext;
763 0u, // VkImageCreateFlags flags;
764 m_params.dst.image.imageType, // VkImageType imageType;
765 m_params.dst.image.format, // VkFormat format;
766 getExtent3D(m_params.dst.image), // VkExtent3D extent;
767 1u, // deUint32 mipLevels;
768 getArraySize(m_params.dst.image), // deUint32 arraySize;
769 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
770 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
771 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
772 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
773 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
774 1u, // deUint32 queueFamilyCount;
775 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
776 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
779 m_destination = createImage(vk, vkDevice, &destinationImageParams);
780 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
781 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
785 tcu::TestStatus CopyImageToImage::iterate (void)
787 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
788 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
789 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
790 (int)m_params.src.image.extent.width,
791 (int)m_params.src.image.extent.height,
792 (int)m_params.src.image.extent.depth));
793 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);
794 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
795 (int)m_params.dst.image.extent.width,
796 (int)m_params.dst.image.extent.height,
797 (int)m_params.dst.image.extent.depth));
798 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);
799 generateExpectedResult();
801 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
802 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
804 const DeviceInterface& vk = m_context.getDeviceInterface();
805 const VkDevice vkDevice = m_context.getDevice();
806 const VkQueue queue = m_context.getUniversalQueue();
808 std::vector<VkImageCopy> imageCopies;
809 for (deUint32 i = 0; i < m_params.regions.size(); i++)
810 imageCopies.push_back(m_params.regions[i].imageCopy);
812 const VkImageMemoryBarrier imageBarriers[] =
816 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
817 DE_NULL, // const void* pNext;
818 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
819 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
820 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
821 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
822 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
823 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
824 m_source.get(), // VkImage image;
825 { // VkImageSubresourceRange subresourceRange;
826 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
827 0u, // deUint32 baseMipLevel;
828 1u, // deUint32 mipLevels;
829 0u, // deUint32 baseArraySlice;
830 getArraySize(m_params.src.image)// deUint32 arraySize;
835 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
836 DE_NULL, // const void* pNext;
837 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
838 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
839 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
840 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
841 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
842 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
843 m_destination.get(), // VkImage image;
844 { // VkImageSubresourceRange subresourceRange;
845 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
846 0u, // deUint32 baseMipLevel;
847 1u, // deUint32 mipLevels;
848 0u, // deUint32 baseArraySlice;
849 getArraySize(m_params.dst.image)// deUint32 arraySize;
854 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
856 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
857 DE_NULL, // const void* pNext;
858 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
859 (const VkCommandBufferInheritanceInfo*)DE_NULL,
862 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
863 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);
864 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());
865 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
867 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
869 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
871 return checkTestResult(resultTextureLevel->getAccess());
874 tcu::TestStatus CopyImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
876 const tcu::Vec4 fThreshold (0.0f);
877 const tcu::UVec4 uThreshold (0u);
879 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
881 if (tcu::hasDepthComponent(result.getFormat().order))
883 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_DEPTH;
884 const tcu::ConstPixelBufferAccess depthResult = tcu::getEffectiveDepthStencilAccess(result, mode);
885 const tcu::ConstPixelBufferAccess expectedResult = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
887 if (isFloatFormat(result.getFormat()))
889 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, depthResult, fThreshold, tcu::COMPARE_LOG_RESULT))
890 return tcu::TestStatus::fail("CopiesAndBlitting test");
894 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, depthResult, uThreshold, tcu::COMPARE_LOG_RESULT))
895 return tcu::TestStatus::fail("CopiesAndBlitting test");
899 if (tcu::hasStencilComponent(result.getFormat().order))
901 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_STENCIL;
902 const tcu::ConstPixelBufferAccess stencilResult = tcu::getEffectiveDepthStencilAccess(result, mode);
903 const tcu::ConstPixelBufferAccess expectedResult = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
905 if (isFloatFormat(result.getFormat()))
907 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, stencilResult, fThreshold, tcu::COMPARE_LOG_RESULT))
908 return tcu::TestStatus::fail("CopiesAndBlitting test");
912 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, stencilResult, uThreshold, tcu::COMPARE_LOG_RESULT))
913 return tcu::TestStatus::fail("CopiesAndBlitting test");
919 if (isFloatFormat(result.getFormat()))
921 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", m_expectedTextureLevel->getAccess(), result, fThreshold, tcu::COMPARE_LOG_RESULT))
922 return tcu::TestStatus::fail("CopiesAndBlitting test");
926 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", m_expectedTextureLevel->getAccess(), result, uThreshold, tcu::COMPARE_LOG_RESULT))
927 return tcu::TestStatus::fail("CopiesAndBlitting test");
931 return tcu::TestStatus::pass("CopiesAndBlitting test");
934 void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
936 VkOffset3D srcOffset = region.imageCopy.srcOffset;
937 VkOffset3D dstOffset = region.imageCopy.dstOffset;
938 VkExtent3D extent = region.imageCopy.extent;
940 if (m_params.src.image.imageType == VK_IMAGE_TYPE_3D && m_params.dst.image.imageType == VK_IMAGE_TYPE_2D)
941 dstOffset.z = srcOffset.z;
942 if (m_params.src.image.imageType == VK_IMAGE_TYPE_2D && m_params.dst.image.imageType == VK_IMAGE_TYPE_3D)
944 srcOffset.z = dstOffset.z;
945 extent.depth = std::max(region.imageCopy.extent.depth, region.imageCopy.srcSubresource.layerCount);
949 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
951 DE_ASSERT(src.getFormat() == dst.getFormat());
954 if (tcu::hasDepthComponent(src.getFormat().order))
956 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
957 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
958 tcu::copy(dstSubRegion, srcSubRegion);
962 if (tcu::hasStencilComponent(src.getFormat().order))
964 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
965 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
966 tcu::copy(dstSubRegion, srcSubRegion);
971 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
972 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
973 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
974 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
976 tcu::copy(dstSubRegion, srcSubRegion);
980 class CopyImageToImageTestCase : public vkt::TestCase
983 CopyImageToImageTestCase (tcu::TestContext& testCtx,
984 const std::string& name,
985 const std::string& description,
986 const TestParams params)
987 : vkt::TestCase (testCtx, name, description)
991 virtual TestInstance* createInstance (Context& context) const
993 return new CopyImageToImage(context, m_params);
999 // Copy from buffer to buffer.
1001 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
1004 CopyBufferToBuffer (Context& context, TestParams params);
1005 virtual tcu::TestStatus iterate (void);
1007 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
1008 Move<VkBuffer> m_source;
1009 de::MovePtr<Allocation> m_sourceBufferAlloc;
1010 Move<VkBuffer> m_destination;
1011 de::MovePtr<Allocation> m_destinationBufferAlloc;
1014 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
1015 : CopiesAndBlittingTestInstance (context, params)
1017 const DeviceInterface& vk = context.getDeviceInterface();
1018 const VkDevice vkDevice = context.getDevice();
1019 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1020 Allocator& memAlloc = context.getDefaultAllocator();
1022 // Create source buffer
1024 const VkBufferCreateInfo sourceBufferParams =
1026 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1027 DE_NULL, // const void* pNext;
1028 0u, // VkBufferCreateFlags flags;
1029 m_params.src.buffer.size, // VkDeviceSize size;
1030 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1031 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1032 1u, // deUint32 queueFamilyIndexCount;
1033 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1036 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1037 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1038 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1041 // Create destination buffer
1043 const VkBufferCreateInfo destinationBufferParams =
1045 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1046 DE_NULL, // const void* pNext;
1047 0u, // VkBufferCreateFlags flags;
1048 m_params.dst.buffer.size, // VkDeviceSize size;
1049 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1050 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1051 1u, // deUint32 queueFamilyIndexCount;
1052 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1055 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1056 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1057 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1061 tcu::TestStatus CopyBufferToBuffer::iterate (void)
1063 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
1064 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
1065 generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
1067 const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
1068 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1069 generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
1071 generateExpectedResult();
1073 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1074 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1076 const DeviceInterface& vk = m_context.getDeviceInterface();
1077 const VkDevice vkDevice = m_context.getDevice();
1078 const VkQueue queue = m_context.getUniversalQueue();
1080 const VkBufferMemoryBarrier srcBufferBarrier =
1082 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1083 DE_NULL, // const void* pNext;
1084 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
1085 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1086 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1087 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1088 *m_source, // VkBuffer buffer;
1089 0u, // VkDeviceSize offset;
1090 m_params.src.buffer.size // VkDeviceSize size;
1093 const VkBufferMemoryBarrier dstBufferBarrier =
1095 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1096 DE_NULL, // const void* pNext;
1097 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1098 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1099 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1100 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1101 *m_destination, // VkBuffer buffer;
1102 0u, // VkDeviceSize offset;
1103 m_params.dst.buffer.size // VkDeviceSize size;
1106 std::vector<VkBufferCopy> bufferCopies;
1107 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1108 bufferCopies.push_back(m_params.regions[i].bufferCopy);
1110 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1112 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1113 DE_NULL, // const void* pNext;
1114 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1115 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1118 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1119 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);
1120 vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), &bufferCopies[0]);
1121 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);
1122 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1123 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1128 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1129 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
1130 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1132 return checkTestResult(resultLevel->getAccess());
1135 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1137 deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
1138 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
1139 (size_t)region.bufferCopy.size);
1142 class BufferToBufferTestCase : public vkt::TestCase
1145 BufferToBufferTestCase (tcu::TestContext& testCtx,
1146 const std::string& name,
1147 const std::string& description,
1148 const TestParams params)
1149 : vkt::TestCase (testCtx, name, description)
1153 virtual TestInstance* createInstance (Context& context) const
1155 return new CopyBufferToBuffer(context, m_params);
1158 TestParams m_params;
1161 // Copy from image to buffer.
1163 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1166 CopyImageToBuffer (Context& context,
1167 TestParams testParams);
1168 virtual tcu::TestStatus iterate (void);
1170 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1172 tcu::TextureFormat m_textureFormat;
1173 VkDeviceSize m_bufferSize;
1175 Move<VkImage> m_source;
1176 de::MovePtr<Allocation> m_sourceImageAlloc;
1177 Move<VkBuffer> m_destination;
1178 de::MovePtr<Allocation> m_destinationBufferAlloc;
1181 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1182 : CopiesAndBlittingTestInstance(context, testParams)
1183 , m_textureFormat(mapVkFormat(testParams.src.image.format))
1184 , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1186 const DeviceInterface& vk = context.getDeviceInterface();
1187 const VkDevice vkDevice = context.getDevice();
1188 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1189 Allocator& memAlloc = context.getDefaultAllocator();
1191 // Create source image
1193 const VkImageCreateInfo sourceImageParams =
1195 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1196 DE_NULL, // const void* pNext;
1197 0u, // VkImageCreateFlags flags;
1198 m_params.src.image.imageType, // VkImageType imageType;
1199 m_params.src.image.format, // VkFormat format;
1200 getExtent3D(m_params.src.image), // VkExtent3D extent;
1201 1u, // deUint32 mipLevels;
1202 getArraySize(m_params.src.image), // deUint32 arraySize;
1203 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1204 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1205 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1206 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1207 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1208 1u, // deUint32 queueFamilyCount;
1209 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1210 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1213 m_source = createImage(vk, vkDevice, &sourceImageParams);
1214 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1215 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1218 // Create destination buffer
1220 const VkBufferCreateInfo destinationBufferParams =
1222 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1223 DE_NULL, // const void* pNext;
1224 0u, // VkBufferCreateFlags flags;
1225 m_bufferSize, // VkDeviceSize size;
1226 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1227 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1228 1u, // deUint32 queueFamilyIndexCount;
1229 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1232 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1233 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1234 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1238 tcu::TestStatus CopyImageToBuffer::iterate (void)
1240 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1241 m_params.src.image.extent.width,
1242 m_params.src.image.extent.height,
1243 m_params.src.image.extent.depth));
1244 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
1245 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1246 generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1248 generateExpectedResult();
1250 uploadImage(m_sourceTextureLevel->getAccess(), *m_source, m_params.src.image);
1251 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1253 const DeviceInterface& vk = m_context.getDeviceInterface();
1254 const VkDevice vkDevice = m_context.getDevice();
1255 const VkQueue queue = m_context.getUniversalQueue();
1257 // Barriers for copying image to buffer
1258 const VkImageMemoryBarrier imageBarrier =
1260 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1261 DE_NULL, // const void* pNext;
1262 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1263 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1264 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1265 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1266 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1267 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1268 *m_source, // VkImage image;
1269 { // VkImageSubresourceRange subresourceRange;
1270 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1271 0u, // deUint32 baseMipLevel;
1272 1u, // deUint32 mipLevels;
1273 0u, // deUint32 baseArraySlice;
1274 1u // deUint32 arraySize;
1278 const VkBufferMemoryBarrier bufferBarrier =
1280 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1281 DE_NULL, // const void* pNext;
1282 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1283 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1284 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1285 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1286 *m_destination, // VkBuffer buffer;
1287 0u, // VkDeviceSize offset;
1288 m_bufferSize // VkDeviceSize size;
1291 // Copy from image to buffer
1292 std::vector<VkBufferImageCopy> bufferImageCopies;
1293 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1294 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1296 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1298 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1299 DE_NULL, // const void* pNext;
1300 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1301 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1304 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1305 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);
1306 vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), &bufferImageCopies[0]);
1307 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);
1308 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1310 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1313 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1314 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1315 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1317 return checkTestResult(resultLevel->getAccess());
1320 class CopyImageToBufferTestCase : public vkt::TestCase
1323 CopyImageToBufferTestCase (tcu::TestContext& testCtx,
1324 const std::string& name,
1325 const std::string& description,
1326 const TestParams params)
1327 : vkt::TestCase (testCtx, name, description)
1331 virtual TestInstance* createInstance (Context& context) const
1333 return new CopyImageToBuffer(context, m_params);
1336 TestParams m_params;
1339 void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1341 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1343 rowLength = region.bufferImageCopy.imageExtent.width;
1345 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1347 imageHeight = region.bufferImageCopy.imageExtent.height;
1349 const int texelSize = src.getFormat().getPixelSize();
1350 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1351 const VkOffset3D srcOffset = region.bufferImageCopy.imageOffset;
1352 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1354 for (deUint32 z = 0; z < extent.depth; z++)
1356 for (deUint32 y = 0; y < extent.height; y++)
1358 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1359 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1360 region.bufferImageCopy.imageExtent.width, 1, 1);
1361 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1362 tcu::copy(dstSubRegion, srcSubRegion);
1367 // Copy from buffer to image.
1369 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1372 CopyBufferToImage (Context& context,
1373 TestParams testParams);
1374 virtual tcu::TestStatus iterate (void);
1376 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1378 tcu::TextureFormat m_textureFormat;
1379 VkDeviceSize m_bufferSize;
1381 Move<VkBuffer> m_source;
1382 de::MovePtr<Allocation> m_sourceBufferAlloc;
1383 Move<VkImage> m_destination;
1384 de::MovePtr<Allocation> m_destinationImageAlloc;
1387 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1388 : CopiesAndBlittingTestInstance(context, testParams)
1389 , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1390 , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1392 const DeviceInterface& vk = context.getDeviceInterface();
1393 const VkDevice vkDevice = context.getDevice();
1394 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1395 Allocator& memAlloc = context.getDefaultAllocator();
1397 // Create source buffer
1399 const VkBufferCreateInfo sourceBufferParams =
1401 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1402 DE_NULL, // const void* pNext;
1403 0u, // VkBufferCreateFlags flags;
1404 m_bufferSize, // VkDeviceSize size;
1405 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1406 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1407 1u, // deUint32 queueFamilyIndexCount;
1408 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1411 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1412 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1413 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1416 // Create destination image
1418 const VkImageCreateInfo destinationImageParams =
1420 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1421 DE_NULL, // const void* pNext;
1422 0u, // VkImageCreateFlags flags;
1423 m_params.dst.image.imageType, // VkImageType imageType;
1424 m_params.dst.image.format, // VkFormat format;
1425 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1426 1u, // deUint32 mipLevels;
1427 getArraySize(m_params.dst.image), // deUint32 arraySize;
1428 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1429 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1430 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1431 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1432 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1433 1u, // deUint32 queueFamilyCount;
1434 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1435 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1438 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1439 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1440 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1444 tcu::TestStatus CopyBufferToImage::iterate (void)
1446 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1447 generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1448 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1449 m_params.dst.image.extent.width,
1450 m_params.dst.image.extent.height,
1451 m_params.dst.image.extent.depth));
1453 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
1455 generateExpectedResult();
1457 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1458 uploadImage(m_destinationTextureLevel->getAccess(), *m_destination, m_params.dst.image);
1460 const DeviceInterface& vk = m_context.getDeviceInterface();
1461 const VkDevice vkDevice = m_context.getDevice();
1462 const VkQueue queue = m_context.getUniversalQueue();
1464 const VkImageMemoryBarrier imageBarrier =
1466 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1467 DE_NULL, // const void* pNext;
1468 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1469 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1470 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1471 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1472 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1473 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1474 *m_destination, // VkImage image;
1475 { // VkImageSubresourceRange subresourceRange;
1476 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1477 0u, // deUint32 baseMipLevel;
1478 1u, // deUint32 mipLevels;
1479 0u, // deUint32 baseArraySlice;
1480 1u // deUint32 arraySize;
1484 // Copy from buffer to image
1485 std::vector<VkBufferImageCopy> bufferImageCopies;
1486 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1487 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1489 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1491 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1492 DE_NULL, // const void* pNext;
1493 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1494 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1497 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1498 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);
1499 vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies.data());
1500 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1502 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1504 de::MovePtr<tcu::TextureLevel> resultLevel = readImage(*m_destination, m_params.dst.image);
1506 return checkTestResult(resultLevel->getAccess());
1509 class CopyBufferToImageTestCase : public vkt::TestCase
1512 CopyBufferToImageTestCase (tcu::TestContext& testCtx,
1513 const std::string& name,
1514 const std::string& description,
1515 const TestParams params)
1516 : vkt::TestCase (testCtx, name, description)
1520 virtual ~CopyBufferToImageTestCase (void) {}
1522 virtual TestInstance* createInstance (Context& context) const
1524 return new CopyBufferToImage(context, m_params);
1527 TestParams m_params;
1530 void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1532 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1534 rowLength = region.bufferImageCopy.imageExtent.width;
1536 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1538 imageHeight = region.bufferImageCopy.imageExtent.height;
1540 const int texelSize = dst.getFormat().getPixelSize();
1541 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1542 const VkOffset3D dstOffset = region.bufferImageCopy.imageOffset;
1543 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1545 for (deUint32 z = 0; z < extent.depth; z++)
1547 for (deUint32 y = 0; y < extent.height; y++)
1549 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1550 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1551 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1552 region.bufferImageCopy.imageExtent.width, 1, 1);
1553 tcu::copy(dstSubRegion, srcSubRegion);
1558 // Copy from image to image with scaling.
1560 class BlittingImages : public CopiesAndBlittingTestInstance
1563 BlittingImages (Context& context,
1565 virtual tcu::TestStatus iterate (void);
1567 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
1568 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1569 virtual void generateExpectedResult (void);
1571 bool checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess& result,
1572 const tcu::ConstPixelBufferAccess& clampedReference,
1573 const tcu::ConstPixelBufferAccess& unclampedReference,
1574 VkImageAspectFlagBits aspect);
1575 Move<VkImage> m_source;
1576 de::MovePtr<Allocation> m_sourceImageAlloc;
1577 Move<VkImage> m_destination;
1578 de::MovePtr<Allocation> m_destinationImageAlloc;
1580 de::MovePtr<tcu::TextureLevel> m_unclampedExpectedTextureLevel;
1583 BlittingImages::BlittingImages (Context& context, TestParams params)
1584 : CopiesAndBlittingTestInstance(context, params)
1586 const DeviceInterface& vk = context.getDeviceInterface();
1587 const VkDevice vkDevice = context.getDevice();
1588 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1589 Allocator& memAlloc = context.getDefaultAllocator();
1591 VkImageFormatProperties properties;
1592 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1593 m_params.src.image.format,
1595 VK_IMAGE_TILING_OPTIMAL,
1596 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1598 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
1599 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1600 m_params.dst.image.format,
1602 VK_IMAGE_TILING_OPTIMAL,
1603 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1605 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
1607 TCU_THROW(NotSupportedError, "Format not supported");
1610 VkFormatProperties srcFormatProperties;
1611 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.src.image.format, &srcFormatProperties);
1612 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT))
1614 TCU_THROW(NotSupportedError, "Format feature blit source not supported");
1617 VkFormatProperties dstFormatProperties;
1618 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.dst.image.format, &dstFormatProperties);
1619 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT))
1621 TCU_THROW(NotSupportedError, "Format feature blit destination not supported");
1624 if (m_params.filter == VK_FILTER_LINEAR)
1626 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1627 TCU_THROW(NotSupportedError, "Source format feature sampled image filter linear not supported");
1628 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1629 TCU_THROW(NotSupportedError, "Destination format feature sampled image filter linear not supported");
1632 // Create source image
1634 const VkImageCreateInfo sourceImageParams =
1636 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1637 DE_NULL, // const void* pNext;
1638 0u, // VkImageCreateFlags flags;
1639 m_params.src.image.imageType, // VkImageType imageType;
1640 m_params.src.image.format, // VkFormat format;
1641 getExtent3D(m_params.src.image), // VkExtent3D extent;
1642 1u, // deUint32 mipLevels;
1643 getArraySize(m_params.src.image), // deUint32 arraySize;
1644 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1645 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1646 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1647 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1648 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1649 1u, // deUint32 queueFamilyCount;
1650 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1651 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1654 m_source = createImage(vk, vkDevice, &sourceImageParams);
1655 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1656 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1659 // Create destination image
1661 const VkImageCreateInfo destinationImageParams =
1663 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1664 DE_NULL, // const void* pNext;
1665 0u, // VkImageCreateFlags flags;
1666 m_params.dst.image.imageType, // VkImageType imageType;
1667 m_params.dst.image.format, // VkFormat format;
1668 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1669 1u, // deUint32 mipLevels;
1670 getArraySize(m_params.dst.image), // deUint32 arraySize;
1671 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1672 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1673 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1674 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1675 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1676 1u, // deUint32 queueFamilyCount;
1677 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1678 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1681 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1682 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1683 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1687 tcu::TestStatus BlittingImages::iterate (void)
1689 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
1690 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
1691 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
1692 m_params.src.image.extent.width,
1693 m_params.src.image.extent.height,
1694 m_params.src.image.extent.depth));
1695 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);
1696 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
1697 (int)m_params.dst.image.extent.width,
1698 (int)m_params.dst.image.extent.height,
1699 (int)m_params.dst.image.extent.depth));
1700 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);
1701 generateExpectedResult();
1703 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
1704 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
1706 const DeviceInterface& vk = m_context.getDeviceInterface();
1707 const VkDevice vkDevice = m_context.getDevice();
1708 const VkQueue queue = m_context.getUniversalQueue();
1710 std::vector<VkImageBlit> regions;
1711 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1712 regions.push_back(m_params.regions[i].imageBlit);
1714 // Barriers for copying image to buffer
1715 const VkImageMemoryBarrier srcImageBarrier =
1717 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1718 DE_NULL, // const void* pNext;
1719 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1720 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1721 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1722 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1723 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1724 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1725 m_source.get(), // VkImage image;
1726 { // VkImageSubresourceRange subresourceRange;
1727 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
1728 0u, // deUint32 baseMipLevel;
1729 1u, // deUint32 mipLevels;
1730 0u, // deUint32 baseArraySlice;
1731 1u // deUint32 arraySize;
1735 const VkImageMemoryBarrier dstImageBarrier =
1737 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1738 DE_NULL, // const void* pNext;
1739 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1740 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1741 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1742 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1743 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1744 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1745 m_destination.get(), // VkImage image;
1746 { // VkImageSubresourceRange subresourceRange;
1747 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
1748 0u, // deUint32 baseMipLevel;
1749 1u, // deUint32 mipLevels;
1750 0u, // deUint32 baseArraySlice;
1751 1u // deUint32 arraySize;
1755 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1757 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1758 DE_NULL, // const void* pNext;
1759 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1760 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1763 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1764 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);
1765 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);
1766 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);
1767 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1768 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1770 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
1772 return checkTestResult(resultTextureLevel->getAccess());
1775 static float calculateFloatConversionError (int srcBits)
1779 const int clampedBits = de::clamp<int>(srcBits, 0, 32);
1780 const float srcMaxValue = de::max((float)(1ULL<<clampedBits) - 1.0f, 1.0f);
1781 const float error = 1.0f / srcMaxValue;
1783 return de::clamp<float>(error, 0.0f, 1.0f);
1789 tcu::Vec4 getFormatThreshold (const tcu::TextureFormat& format)
1791 tcu::Vec4 threshold(0.01f);
1793 switch (format.type)
1795 case tcu::TextureFormat::HALF_FLOAT:
1796 threshold = tcu::Vec4(0.005f);
1799 case tcu::TextureFormat::FLOAT:
1800 case tcu::TextureFormat::FLOAT64:
1801 threshold = tcu::Vec4(0.001f);
1804 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1805 threshold = tcu::Vec4(0.02f, 0.02f, 0.0625f, 1.0f);
1808 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1809 threshold = tcu::Vec4(0.05f, 0.05f, 0.05f, 1.0f);
1813 const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(format);
1814 threshold = tcu::Vec4(calculateFloatConversionError(bits.x()),
1815 calculateFloatConversionError(bits.y()),
1816 calculateFloatConversionError(bits.z()),
1817 calculateFloatConversionError(bits.w()));
1820 // Return value matching the channel order specified by the format
1821 if (format.order == tcu::TextureFormat::BGR || format.order == tcu::TextureFormat::BGRA)
1822 return threshold.swizzle(2, 1, 0, 3);
1827 tcu::TextureFormat getFormatAspect (VkFormat format, VkImageAspectFlagBits aspect)
1829 const tcu::TextureFormat baseFormat = mapVkFormat(format);
1831 if (isCombinedDepthStencilType(baseFormat.type))
1833 if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT)
1834 return getEffectiveDepthStencilTextureFormat(baseFormat, tcu::Sampler::MODE_DEPTH);
1835 else if (aspect == VK_IMAGE_ASPECT_STENCIL_BIT)
1836 return getEffectiveDepthStencilTextureFormat(baseFormat, tcu::Sampler::MODE_STENCIL);
1838 DE_FATAL("Invalid aspect");
1844 bool BlittingImages::checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess& result,
1845 const tcu::ConstPixelBufferAccess& clampedExpected,
1846 const tcu::ConstPixelBufferAccess& unclampedExpected,
1847 VkImageAspectFlagBits aspect)
1849 tcu::TestLog& log (m_context.getTestContext().getLog());
1850 const bool isLinear = m_params.filter == VK_FILTER_LINEAR;
1851 const tcu::TextureFormat srcFormat = getFormatAspect(m_params.src.image.format, aspect);
1852 const tcu::TextureFormat dstFormat = result.getFormat();
1855 DE_ASSERT(dstFormat == getFormatAspect(m_params.dst.image.format, aspect));
1858 log << tcu::TestLog::Section("ClampedSourceImage", "Region with clamped edges on source image.");
1860 if (isFloatFormat(dstFormat))
1862 const bool srcIsSRGB = tcu::isSRGB(srcFormat);
1863 const tcu::Vec4 srcMaxDiff = getFormatThreshold(srcFormat) * tcu::Vec4(srcIsSRGB ? 2.0f : 1.0f);
1864 const tcu::Vec4 dstMaxDiff = getFormatThreshold(dstFormat);
1865 const tcu::Vec4 threshold = tcu::max(srcMaxDiff, dstMaxDiff);
1867 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1870 log << tcu::TestLog::EndSection;
1872 if (!isOk && isLinear)
1874 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1875 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1876 log << tcu::TestLog::EndSection;
1881 tcu::UVec4 threshold;
1882 // Calculate threshold depending on channel width of destination format.
1883 const tcu::IVec4 bitDepth = tcu::getTextureFormatBitDepth(dstFormat);
1884 for (deUint32 i = 0; i < 4; ++i)
1885 threshold[i] = de::max( (0x1 << bitDepth[i]) / 256, 1);
1887 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1890 log << tcu::TestLog::EndSection;
1892 if (!isOk && isLinear)
1894 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1895 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1896 log << tcu::TestLog::EndSection;
1902 tcu::TestStatus BlittingImages::checkTestResult (tcu::ConstPixelBufferAccess result)
1904 DE_ASSERT(m_params.filter == VK_FILTER_NEAREST || m_params.filter == VK_FILTER_LINEAR);
1906 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
1908 if (tcu::hasDepthComponent(result.getFormat().order))
1910 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_DEPTH;
1911 const tcu::ConstPixelBufferAccess depthResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1912 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1913 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1915 if (!checkClampedAndUnclampedResult(depthResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_DEPTH_BIT))
1917 return tcu::TestStatus::fail("CopiesAndBlitting test");
1921 if (tcu::hasStencilComponent(result.getFormat().order))
1923 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_STENCIL;
1924 const tcu::ConstPixelBufferAccess stencilResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1925 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1926 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1928 if (!checkClampedAndUnclampedResult(stencilResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_STENCIL_BIT))
1930 return tcu::TestStatus::fail("CopiesAndBlitting test");
1936 if (!checkClampedAndUnclampedResult(result, m_expectedTextureLevel->getAccess(), m_params.filter == VK_FILTER_LINEAR ? m_unclampedExpectedTextureLevel->getAccess() : tcu::ConstPixelBufferAccess(), VK_IMAGE_ASPECT_COLOR_BIT))
1938 return tcu::TestStatus::fail("CopiesAndBlitting test");
1942 return tcu::TestStatus::pass("CopiesAndBlitting test");
1945 tcu::Vec4 linearToSRGBIfNeeded (const tcu::TextureFormat& format, const tcu::Vec4& color)
1947 return isSRGB(format) ? linearToSRGB(color) : color;
1950 void scaleFromWholeSrcBuffer (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const VkOffset3D regionOffset, const VkOffset3D regionExtent, tcu::Sampler::FilterMode filter)
1952 DE_ASSERT(filter == tcu::Sampler::LINEAR);
1953 DE_ASSERT(dst.getDepth() == 1 && src.getDepth() == 1);
1955 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1956 filter, filter, 0.0f, false);
1958 float sX = (float)regionExtent.x / (float)dst.getWidth();
1959 float sY = (float)regionExtent.y / (float)dst.getHeight();
1961 for (int y = 0; y < dst.getHeight(); y++)
1962 for (int x = 0; x < dst.getWidth(); x++)
1963 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);
1966 void blit (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const tcu::Sampler::FilterMode filter, const MirrorMode mirrorMode)
1968 DE_ASSERT(filter == tcu::Sampler::NEAREST || filter == tcu::Sampler::LINEAR);
1970 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1971 filter, filter, 0.0f, false);
1973 const float sX = (float)src.getWidth() / (float)dst.getWidth();
1974 const float sY = (float)src.getHeight() / (float)dst.getHeight();
1975 const float sZ = (float)src.getDepth() / (float)dst.getDepth();
1977 tcu::Mat2 rotMatrix;
1978 rotMatrix(0,0) = (mirrorMode & MIRROR_MODE_X) ? -1.0f : 1.0f;
1979 rotMatrix(0,1) = 0.0f;
1980 rotMatrix(1,0) = 0.0f;
1981 rotMatrix(1,1) = (mirrorMode & MIRROR_MODE_Y) ? -1.0f : 1.0f;
1983 const int xOffset = (mirrorMode & MIRROR_MODE_X) ? dst.getWidth() - 1 : 0;
1984 const int yOffset = (mirrorMode & MIRROR_MODE_Y) ? dst.getHeight() - 1 : 0;
1986 if (dst.getDepth() == 1 && src.getDepth() == 1)
1988 for (int y = 0; y < dst.getHeight(); ++y)
1989 for (int x = 0; x < dst.getWidth(); ++x)
1991 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1992 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);
1997 for (int z = 0; z < dst.getDepth(); ++z)
1998 for (int y = 0; y < dst.getHeight(); ++y)
1999 for (int x = 0; x < dst.getWidth(); ++x)
2001 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
2002 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);
2007 void flipCoordinates (CopyRegion& region, const MirrorMode mirrorMode)
2009 const VkOffset3D dstOffset0 = region.imageBlit.dstOffsets[0];
2010 const VkOffset3D dstOffset1 = region.imageBlit.dstOffsets[1];
2011 const VkOffset3D srcOffset0 = region.imageBlit.srcOffsets[0];
2012 const VkOffset3D srcOffset1 = region.imageBlit.srcOffsets[1];
2014 if (mirrorMode > MIRROR_MODE_NONE && mirrorMode < MIRROR_MODE_LAST)
2017 region.imageBlit.srcOffsets[0].x = std::min(srcOffset0.x, srcOffset1.x);
2018 region.imageBlit.srcOffsets[0].y = std::min(srcOffset0.y, srcOffset1.y);
2020 region.imageBlit.srcOffsets[1].x = std::max(srcOffset0.x, srcOffset1.x);
2021 region.imageBlit.srcOffsets[1].y = std::max(srcOffset0.y, srcOffset1.y);
2024 region.imageBlit.dstOffsets[0].x = std::min(dstOffset0.x, dstOffset1.x);
2025 region.imageBlit.dstOffsets[0].y = std::min(dstOffset0.y, dstOffset1.y);
2027 region.imageBlit.dstOffsets[1].x = std::max(dstOffset0.x, dstOffset1.x);
2028 region.imageBlit.dstOffsets[1].y = std::max(dstOffset0.y, dstOffset1.y);
2032 MirrorMode getMirrorMode(const VkOffset3D x1, const VkOffset3D x2)
2034 if (x1.x >= x2.x && x1.y >= x2.y)
2036 return MIRROR_MODE_XY;
2038 else if (x1.x <= x2.x && x1.y <= x2.y)
2040 return MIRROR_MODE_NONE;
2042 else if (x1.x <= x2.x && x1.y >= x2.y)
2044 return MIRROR_MODE_Y;
2046 else if (x1.x >= x2.x && x1.y <= x2.y)
2048 return MIRROR_MODE_X;
2050 return MIRROR_MODE_LAST;
2053 MirrorMode getMirrorMode(const VkOffset3D s1, const VkOffset3D s2, const VkOffset3D d1, const VkOffset3D d2)
2055 const MirrorMode source = getMirrorMode(s1, s2);
2056 const MirrorMode destination = getMirrorMode(d1, d2);
2058 if (source == destination)
2060 return MIRROR_MODE_NONE;
2062 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_X) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_X) ||
2063 (source == MIRROR_MODE_Y && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_Y && source == MIRROR_MODE_NONE))
2065 return MIRROR_MODE_Y;
2067 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_Y) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_Y) ||
2068 (source == MIRROR_MODE_X && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_X && source == MIRROR_MODE_NONE))
2070 return MIRROR_MODE_X;
2072 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_NONE))
2074 return MIRROR_MODE_XY;
2076 return MIRROR_MODE_LAST;
2079 void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2081 const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
2082 region.imageBlit.srcOffsets[1],
2083 region.imageBlit.dstOffsets[0],
2084 region.imageBlit.dstOffsets[1]);
2086 flipCoordinates(region, mirrorMode);
2088 const VkOffset3D srcOffset = region.imageBlit.srcOffsets[0];
2089 const VkOffset3D srcExtent =
2091 region.imageBlit.srcOffsets[1].x - srcOffset.x,
2092 region.imageBlit.srcOffsets[1].y - srcOffset.y,
2093 region.imageBlit.srcOffsets[1].z - srcOffset.z
2095 const VkOffset3D dstOffset = region.imageBlit.dstOffsets[0];
2096 const VkOffset3D dstExtent =
2098 region.imageBlit.dstOffsets[1].x - dstOffset.x,
2099 region.imageBlit.dstOffsets[1].y - dstOffset.y,
2100 region.imageBlit.dstOffsets[1].z - dstOffset.z
2102 const tcu::Sampler::FilterMode filter = (m_params.filter == VK_FILTER_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
2104 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
2106 DE_ASSERT(src.getFormat() == dst.getFormat());
2108 if (tcu::hasDepthComponent(src.getFormat().order))
2110 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_DEPTH);
2111 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
2112 tcu::scale(dstSubRegion, srcSubRegion, filter);
2114 if (filter == tcu::Sampler::LINEAR)
2116 const tcu::ConstPixelBufferAccess depthSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH);
2117 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
2118 scaleFromWholeSrcBuffer(unclampedSubRegion, depthSrc, srcOffset, srcExtent, filter);
2123 if (tcu::hasStencilComponent(src.getFormat().order))
2125 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_STENCIL);
2126 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2127 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2129 if (filter == tcu::Sampler::LINEAR)
2131 const tcu::ConstPixelBufferAccess stencilSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL);
2132 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2133 scaleFromWholeSrcBuffer(unclampedSubRegion, stencilSrc, srcOffset, srcExtent, filter);
2139 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y);
2140 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2141 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2143 if (filter == tcu::Sampler::LINEAR)
2145 const tcu::PixelBufferAccess unclampedSubRegion = tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2146 scaleFromWholeSrcBuffer(unclampedSubRegion, src, srcOffset, srcExtent, filter);
2151 void BlittingImages::generateExpectedResult (void)
2153 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
2154 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
2156 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2157 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
2159 if (m_params.filter == VK_FILTER_LINEAR)
2161 m_unclampedExpectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2162 tcu::copy(m_unclampedExpectedTextureLevel->getAccess(), dst);
2165 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2167 CopyRegion region = m_params.regions[i];
2168 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), region);
2172 class BlittingTestCase : public vkt::TestCase
2175 BlittingTestCase (tcu::TestContext& testCtx,
2176 const std::string& name,
2177 const std::string& description,
2178 const TestParams params)
2179 : vkt::TestCase (testCtx, name, description)
2183 virtual TestInstance* createInstance (Context& context) const
2185 return new BlittingImages(context, m_params);
2188 TestParams m_params;
2191 // Resolve image to image.
2193 enum ResolveImageToImageOptions{NO_OPTIONAL_OPERATION, COPY_MS_IMAGE_TO_MS_IMAGE, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE};
2194 class ResolveImageToImage : public CopiesAndBlittingTestInstance
2197 ResolveImageToImage (Context& context,
2199 const ResolveImageToImageOptions options);
2200 virtual tcu::TestStatus iterate (void);
2202 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
2203 void copyMSImageToMSImage (void);
2205 Move<VkImage> m_multisampledImage;
2206 de::MovePtr<Allocation> m_multisampledImageAlloc;
2208 Move<VkImage> m_destination;
2209 de::MovePtr<Allocation> m_destinationImageAlloc;
2211 Move<VkImage> m_multisampledCopyImage;
2212 de::MovePtr<Allocation> m_multisampledCopyImageAlloc;
2214 const ResolveImageToImageOptions m_options;
2216 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src,
2217 tcu::PixelBufferAccess dst,
2221 ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
2222 : CopiesAndBlittingTestInstance (context, params)
2223 , m_options (options)
2225 const VkSampleCountFlagBits rasterizationSamples = m_params.samples;
2227 if (!(context.getDeviceProperties().limits.framebufferColorSampleCounts & rasterizationSamples))
2228 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
2230 const DeviceInterface& vk = context.getDeviceInterface();
2231 const VkDevice vkDevice = context.getDevice();
2232 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2233 Allocator& memAlloc = m_context.getDefaultAllocator();
2235 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
2236 Move<VkRenderPass> renderPass;
2238 Move<VkShaderModule> vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0);
2239 Move<VkShaderModule> fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0);
2240 std::vector<tcu::Vec4> vertices;
2242 Move<VkBuffer> vertexBuffer;
2243 de::MovePtr<Allocation> vertexBufferAlloc;
2245 Move<VkPipelineLayout> pipelineLayout;
2246 Move<VkPipeline> graphicsPipeline;
2248 VkImageFormatProperties properties;
2249 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2250 m_params.src.image.format,
2251 m_params.src.image.imageType,
2252 VK_IMAGE_TILING_OPTIMAL,
2253 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
2254 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
2255 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2256 m_params.dst.image.format,
2257 m_params.dst.image.imageType,
2258 VK_IMAGE_TILING_OPTIMAL,
2259 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
2260 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
2262 TCU_THROW(NotSupportedError, "Format not supported");
2265 // Create color image.
2267 VkImageCreateInfo colorImageParams =
2269 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2270 DE_NULL, // const void* pNext;
2271 0u, // VkImageCreateFlags flags;
2272 m_params.src.image.imageType, // VkImageType imageType;
2273 m_params.src.image.format, // VkFormat format;
2274 getExtent3D(m_params.src.image), // VkExtent3D extent;
2275 1u, // deUint32 mipLevels;
2276 getArraySize(m_params.src.image), // deUint32 arrayLayers;
2277 rasterizationSamples, // VkSampleCountFlagBits samples;
2278 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2279 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage;
2280 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2281 1u, // deUint32 queueFamilyIndexCount;
2282 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2283 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2286 m_multisampledImage = createImage(vk, vkDevice, &colorImageParams);
2288 // Allocate and bind color image memory.
2289 m_multisampledImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledImage), MemoryRequirement::Any);
2290 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledImage, m_multisampledImageAlloc->getMemory(), m_multisampledImageAlloc->getOffset()));
2294 case COPY_MS_IMAGE_TO_MS_IMAGE:
2296 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2297 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2298 // Allocate and bind color image memory.
2299 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2300 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2304 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2306 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2307 colorImageParams.arrayLayers = getArraySize(m_params.dst.image);
2308 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2309 // Allocate and bind color image memory.
2310 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2311 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2320 // Create destination image.
2322 const VkImageCreateInfo destinationImageParams =
2324 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2325 DE_NULL, // const void* pNext;
2326 0u, // VkImageCreateFlags flags;
2327 m_params.dst.image.imageType, // VkImageType imageType;
2328 m_params.dst.image.format, // VkFormat format;
2329 getExtent3D(m_params.dst.image), // VkExtent3D extent;
2330 1u, // deUint32 mipLevels;
2331 getArraySize(m_params.dst.image), // deUint32 arraySize;
2332 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
2333 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2334 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2335 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
2336 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2337 1u, // deUint32 queueFamilyCount;
2338 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2339 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2342 m_destination = createImage(vk, vkDevice, &destinationImageParams);
2343 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
2344 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
2347 // Barriers for copying image to buffer
2348 VkImageMemoryBarrier srcImageBarrier =
2350 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2351 DE_NULL, // const void* pNext;
2352 0u, // VkAccessFlags srcAccessMask;
2353 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2354 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2355 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2356 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2357 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2358 m_multisampledImage.get(), // VkImage image;
2359 { // VkImageSubresourceRange subresourceRange;
2360 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
2361 0u, // deUint32 baseMipLevel;
2362 1u, // deUint32 mipLevels;
2363 0u, // deUint32 baseArraySlice;
2364 getArraySize(m_params.src.image) // deUint32 arraySize;
2368 // Create render pass.
2370 const VkAttachmentDescription attachmentDescriptions[1] =
2373 0u, // VkAttachmentDescriptionFlags flags;
2374 m_params.src.image.format, // VkFormat format;
2375 rasterizationSamples, // VkSampleCountFlagBits samples;
2376 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
2377 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2378 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
2379 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
2380 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
2381 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
2385 const VkAttachmentReference colorAttachmentReference =
2387 0u, // deUint32 attachment;
2388 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2391 const VkSubpassDescription subpassDescription =
2393 0u, // VkSubpassDescriptionFlags flags;
2394 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2395 0u, // deUint32 inputAttachmentCount;
2396 DE_NULL, // const VkAttachmentReference* pInputAttachments;
2397 1u, // deUint32 colorAttachmentCount;
2398 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
2399 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2400 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
2401 0u, // deUint32 preserveAttachmentCount;
2402 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
2405 const VkRenderPassCreateInfo renderPassParams =
2407 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
2408 DE_NULL, // const void* pNext;
2409 0u, // VkRenderPassCreateFlags flags;
2410 1u, // deUint32 attachmentCount;
2411 attachmentDescriptions, // const VkAttachmentDescription* pAttachments;
2412 1u, // deUint32 subpassCount;
2413 &subpassDescription, // const VkSubpassDescription* pSubpasses;
2414 0u, // deUint32 dependencyCount;
2415 DE_NULL // const VkSubpassDependency* pDependencies;
2418 renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
2421 // Create pipeline layout
2423 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
2425 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
2426 DE_NULL, // const void* pNext;
2427 0u, // VkPipelineLayoutCreateFlags flags;
2428 0u, // deUint32 setLayoutCount;
2429 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
2430 0u, // deUint32 pushConstantRangeCount;
2431 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
2434 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2437 // Create upper half triangle.
2439 const tcu::Vec4 a (-1.0, -1.0, 0.0, 1.0);
2440 const tcu::Vec4 b (1.0, -1.0, 0.0, 1.0);
2441 const tcu::Vec4 c (1.0, 1.0, 0.0, 1.0);
2443 vertices.push_back(a);
2444 vertices.push_back(c);
2445 vertices.push_back(b);
2448 // Create vertex buffer.
2450 const VkDeviceSize vertexDataSize = vertices.size() * sizeof(tcu::Vec4);
2451 const VkBufferCreateInfo vertexBufferParams =
2453 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
2454 DE_NULL, // const void* pNext;
2455 0u, // VkBufferCreateFlags flags;
2456 vertexDataSize, // VkDeviceSize size;
2457 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
2458 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2459 1u, // deUint32 queueFamilyIndexCount;
2460 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
2463 vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
2464 vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
2466 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
2468 // Load vertices into vertex buffer.
2469 deMemcpy(vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexDataSize);
2470 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexDataSize);
2474 Move<VkFramebuffer> framebuffer;
2475 Move<VkImageView> sourceAttachmentView;
2476 //const VkExtent3D extent3D = getExtent3D(m_params.src.image); TODO
2478 // Create color attachment view.
2480 const VkImageViewCreateInfo colorAttachmentViewParams =
2482 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
2483 DE_NULL, // const void* pNext;
2484 0u, // VkImageViewCreateFlags flags;
2485 *m_multisampledImage, // VkImage image;
2486 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
2487 m_params.src.image.format, // VkFormat format;
2488 componentMappingRGBA, // VkComponentMapping components;
2489 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
2491 sourceAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
2494 // Create framebuffer
2496 const VkImageView attachments[1] =
2498 *sourceAttachmentView,
2501 const VkFramebufferCreateInfo framebufferParams =
2503 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
2504 DE_NULL, // const void* pNext;
2505 0u, // VkFramebufferCreateFlags flags;
2506 *renderPass, // VkRenderPass renderPass;
2507 1u, // deUint32 attachmentCount;
2508 attachments, // const VkImageView* pAttachments;
2509 m_params.src.image.extent.width, // deUint32 width;
2510 m_params.src.image.extent.height, // deUint32 height;
2511 1u // deUint32 layers;
2514 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
2519 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
2522 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2523 DE_NULL, // const void* pNext;
2524 0u, // VkPipelineShaderStageCreateFlags flags;
2525 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
2526 *vertexShaderModule, // VkShaderModule module;
2527 "main", // const char* pName;
2528 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2531 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2532 DE_NULL, // const void* pNext;
2533 0u, // VkPipelineShaderStageCreateFlags flags;
2534 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
2535 *fragmentShaderModule, // VkShaderModule module;
2536 "main", // const char* pName;
2537 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2541 const VkVertexInputBindingDescription vertexInputBindingDescription =
2543 0u, // deUint32 binding;
2544 sizeof(tcu::Vec4), // deUint32 stride;
2545 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
2548 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[1] =
2551 0u, // deUint32 location;
2552 0u, // deUint32 binding;
2553 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2554 0u // deUint32 offset;
2558 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
2560 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
2561 DE_NULL, // const void* pNext;
2562 0u, // VkPipelineVertexInputStateCreateFlags flags;
2563 1u, // deUint32 vertexBindingDescriptionCount;
2564 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
2565 1u, // deUint32 vertexAttributeDescriptionCount;
2566 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
2569 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
2571 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
2572 DE_NULL, // const void* pNext;
2573 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
2574 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
2575 false // VkBool32 primitiveRestartEnable;
2578 const VkViewport viewport =
2582 (float)m_params.src.image.extent.width, // float width;
2583 (float)m_params.src.image.extent.height,// float height;
2584 0.0f, // float minDepth;
2585 1.0f // float maxDepth;
2588 const VkRect2D scissor =
2590 { 0, 0 }, // VkOffset2D offset;
2591 { m_params.src.image.extent.width, m_params.src.image.extent.height } // VkExtent2D extent;
2594 const VkPipelineViewportStateCreateInfo viewportStateParams =
2596 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
2597 DE_NULL, // const void* pNext;
2598 0u, // VkPipelineViewportStateCreateFlags flags;
2599 1u, // deUint32 viewportCount;
2600 &viewport, // const VkViewport* pViewports;
2601 1u, // deUint32 scissorCount;
2602 &scissor // const VkRect2D* pScissors;
2605 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
2607 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
2608 DE_NULL, // const void* pNext;
2609 0u, // VkPipelineRasterizationStateCreateFlags flags;
2610 false, // VkBool32 depthClampEnable;
2611 false, // VkBool32 rasterizerDiscardEnable;
2612 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
2613 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
2614 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
2615 VK_FALSE, // VkBool32 depthBiasEnable;
2616 0.0f, // float depthBiasConstantFactor;
2617 0.0f, // float depthBiasClamp;
2618 0.0f, // float depthBiasSlopeFactor;
2619 1.0f // float lineWidth;
2622 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
2624 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
2625 DE_NULL, // const void* pNext;
2626 0u, // VkPipelineMultisampleStateCreateFlags flags;
2627 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
2628 VK_FALSE, // VkBool32 sampleShadingEnable;
2629 0.0f, // float minSampleShading;
2630 DE_NULL, // const VkSampleMask* pSampleMask;
2631 VK_FALSE, // VkBool32 alphaToCoverageEnable;
2632 VK_FALSE // VkBool32 alphaToOneEnable;
2635 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
2637 false, // VkBool32 blendEnable;
2638 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor;
2639 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendColor;
2640 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
2641 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha;
2642 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendAlpha;
2643 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
2644 (VK_COLOR_COMPONENT_R_BIT |
2645 VK_COLOR_COMPONENT_G_BIT |
2646 VK_COLOR_COMPONENT_B_BIT |
2647 VK_COLOR_COMPONENT_A_BIT) // VkChannelFlags channelWriteMask;
2650 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
2652 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
2653 DE_NULL, // const void* pNext;
2654 0u, // VkPipelineColorBlendStateCreateFlags flags;
2655 false, // VkBool32 logicOpEnable;
2656 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
2657 1u, // deUint32 attachmentCount;
2658 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2659 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
2662 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
2664 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
2665 DE_NULL, // const void* pNext;
2666 0u, // VkPipelineCreateFlags flags;
2667 2u, // deUint32 stageCount;
2668 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
2669 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
2670 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2671 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
2672 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
2673 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
2674 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
2675 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
2676 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
2677 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2678 *pipelineLayout, // VkPipelineLayout layout;
2679 *renderPass, // VkRenderPass renderPass;
2680 0u, // deUint32 subpass;
2681 0u, // VkPipeline basePipelineHandle;
2682 0u // deInt32 basePipelineIndex;
2685 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
2688 // Create command buffer
2690 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2692 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2693 DE_NULL, // const void* pNext;
2694 0u, // VkCommandBufferUsageFlags flags;
2695 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2698 const VkClearValue clearValues[1] =
2700 makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
2703 const VkRenderPassBeginInfo renderPassBeginInfo =
2705 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2706 DE_NULL, // const void* pNext;
2707 *renderPass, // VkRenderPass renderPass;
2708 *framebuffer, // VkFramebuffer framebuffer;
2711 { m_params.src.image.extent.width, m_params.src.image.extent.height }
2712 }, // VkRect2D renderArea;
2713 1u, // deUint32 clearValueCount;
2714 clearValues // const VkClearValue* pClearValues;
2717 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2718 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);
2719 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2721 const VkDeviceSize vertexBufferOffset = 0u;
2723 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
2724 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer.get(), &vertexBufferOffset);
2725 vk.cmdDraw(*m_cmdBuffer, (deUint32)vertices.size(), 1, 0, 0);
2727 vk.cmdEndRenderPass(*m_cmdBuffer);
2728 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2733 const VkQueue queue = m_context.getUniversalQueue();
2734 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2739 tcu::TestStatus ResolveImageToImage::iterate (void)
2741 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2742 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
2744 // upload the destination image
2745 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
2746 (int)m_params.dst.image.extent.width,
2747 (int)m_params.dst.image.extent.height,
2748 (int)m_params.dst.image.extent.depth));
2749 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
2750 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
2752 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
2753 (int)m_params.src.image.extent.width,
2754 (int)m_params.src.image.extent.height,
2755 (int)m_params.dst.image.extent.depth));
2757 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);
2758 generateExpectedResult();
2762 case COPY_MS_IMAGE_TO_MS_IMAGE:
2763 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2764 copyMSImageToMSImage();
2770 const DeviceInterface& vk = m_context.getDeviceInterface();
2771 const VkDevice vkDevice = m_context.getDevice();
2772 const VkQueue queue = m_context.getUniversalQueue();
2774 std::vector<VkImageResolve> imageResolves;
2775 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2776 imageResolves.push_back(m_params.regions[i].imageResolve);
2778 const VkImageMemoryBarrier imageBarriers[] =
2782 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2783 DE_NULL, // const void* pNext;
2784 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2785 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2786 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2787 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2788 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2789 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2790 m_multisampledImage.get(), // VkImage image;
2791 { // VkImageSubresourceRange subresourceRange;
2792 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2793 0u, // deUint32 baseMipLevel;
2794 1u, // deUint32 mipLevels;
2795 0u, // deUint32 baseArraySlice;
2796 getArraySize(m_params.dst.image) // deUint32 arraySize;
2799 // destination image
2801 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2802 DE_NULL, // const void* pNext;
2803 0u, // VkAccessFlags srcAccessMask;
2804 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2805 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2806 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2807 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2808 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2809 m_destination.get(), // VkImage image;
2810 { // VkImageSubresourceRange subresourceRange;
2811 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2812 0u, // deUint32 baseMipLevel;
2813 1u, // deUint32 mipLevels;
2814 0u, // deUint32 baseArraySlice;
2815 getArraySize(m_params.dst.image) // deUint32 arraySize;
2820 const VkImageMemoryBarrier postImageBarrier =
2822 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2823 DE_NULL, // const void* pNext;
2824 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2825 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2826 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2827 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2828 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2829 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2830 m_destination.get(), // VkImage image;
2831 { // VkImageSubresourceRange subresourceRange;
2832 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2833 0u, // deUint32 baseMipLevel;
2834 1u, // deUint32 mipLevels;
2835 0u, // deUint32 baseArraySlice;
2836 getArraySize(m_params.dst.image) // deUint32 arraySize;
2840 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2842 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2843 DE_NULL, // const void* pNext;
2844 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2845 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2848 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2849 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);
2850 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());
2851 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);
2852 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2853 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
2855 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
2857 return checkTestResult(resultTextureLevel->getAccess());
2860 tcu::TestStatus ResolveImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
2862 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
2863 const float fuzzyThreshold = 0.01f;
2865 for (int arrayLayerNdx = 0; arrayLayerNdx < (int)getArraySize(m_params.dst.image); ++arrayLayerNdx)
2867 const tcu::ConstPixelBufferAccess expectedSub = getSubregion (expected, 0, 0, arrayLayerNdx, expected.getWidth(), expected.getHeight(), 1u);
2868 const tcu::ConstPixelBufferAccess resultSub = getSubregion (result, 0, 0, arrayLayerNdx, result.getWidth(), result.getHeight(), 1u);
2869 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedSub, resultSub, fuzzyThreshold, tcu::COMPARE_LOG_RESULT))
2870 return tcu::TestStatus::fail("CopiesAndBlitting test");
2873 return tcu::TestStatus::pass("CopiesAndBlitting test");
2876 void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2878 VkOffset3D srcOffset = region.imageResolve.srcOffset;
2879 srcOffset.z = region.imageResolve.srcSubresource.baseArrayLayer;
2880 VkOffset3D dstOffset = region.imageResolve.dstOffset;
2881 dstOffset.z = region.imageResolve.dstSubresource.baseArrayLayer;
2882 VkExtent3D extent = region.imageResolve.extent;
2884 const tcu::ConstPixelBufferAccess srcSubRegion = getSubregion (src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
2885 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
2886 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
2887 const tcu::PixelBufferAccess dstSubRegion = getSubregion (dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
2889 tcu::copy(dstSubRegion, srcSubRegion);
2892 void ResolveImageToImage::copyMSImageToMSImage (void)
2894 const DeviceInterface& vk = m_context.getDeviceInterface();
2895 const VkDevice vkDevice = m_context.getDevice();
2896 const VkQueue queue = m_context.getUniversalQueue();
2897 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2898 std::vector<VkImageCopy> imageCopies;
2900 for (deUint32 layerNdx = 0; layerNdx < getArraySize(m_params.dst.image); ++layerNdx)
2902 const VkImageSubresourceLayers sourceSubresourceLayers =
2904 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2905 0u, // uint32_t mipLevel;
2906 0u, // uint32_t baseArrayLayer;
2907 1u // uint32_t layerCount;
2910 const VkImageSubresourceLayers destinationSubresourceLayers =
2912 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;//getAspectFlags(dstTcuFormat)
2913 0u, // uint32_t mipLevel;
2914 layerNdx, // uint32_t baseArrayLayer;
2915 1u // uint32_t layerCount;
2918 const VkImageCopy imageCopy =
2920 sourceSubresourceLayers, // VkImageSubresourceLayers srcSubresource;
2921 {0, 0, 0}, // VkOffset3D srcOffset;
2922 destinationSubresourceLayers, // VkImageSubresourceLayers dstSubresource;
2923 {0, 0, 0}, // VkOffset3D dstOffset;
2924 getExtent3D(m_params.src.image), // VkExtent3D extent;
2926 imageCopies.push_back(imageCopy);
2929 const VkImageMemoryBarrier imageBarriers[] =
2933 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2934 DE_NULL, // const void* pNext;
2935 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2936 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2937 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2938 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2939 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2940 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2941 m_multisampledImage.get(), // VkImage image;
2942 { // VkImageSubresourceRange subresourceRange;
2943 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2944 0u, // deUint32 baseMipLevel;
2945 1u, // deUint32 mipLevels;
2946 0u, // deUint32 baseArraySlice;
2947 getArraySize(m_params.src.image) // deUint32 arraySize;
2950 // destination image
2952 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2953 DE_NULL, // const void* pNext;
2954 0, // VkAccessFlags srcAccessMask;
2955 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2956 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2957 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2958 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2959 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2960 m_multisampledCopyImage.get(), // VkImage image;
2961 { // VkImageSubresourceRange subresourceRange;
2962 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2963 0u, // deUint32 baseMipLevel;
2964 1u, // deUint32 mipLevels;
2965 0u, // deUint32 baseArraySlice;
2966 getArraySize(m_params.dst.image) // deUint32 arraySize;
2971 const VkImageMemoryBarrier postImageBarriers =
2974 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2975 DE_NULL, // const void* pNext;
2976 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2977 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2978 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2979 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2980 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2981 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2982 m_multisampledCopyImage.get(), // VkImage image;
2983 { // VkImageSubresourceRange subresourceRange;
2984 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2985 0u, // deUint32 baseMipLevel;
2986 1u, // deUint32 mipLevels;
2987 0u, // deUint32 baseArraySlice;
2988 getArraySize(m_params.dst.image) // deUint32 arraySize;
2992 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2994 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2995 DE_NULL, // const void* pNext;
2996 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2997 (const VkCommandBufferInheritanceInfo*)DE_NULL,
3000 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
3001 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);
3002 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());
3003 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);
3004 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
3006 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
3008 m_multisampledImage = m_multisampledCopyImage;
3011 class ResolveImageToImageTestCase : public vkt::TestCase
3014 ResolveImageToImageTestCase (tcu::TestContext& testCtx,
3015 const std::string& name,
3016 const std::string& description,
3017 const TestParams params,
3018 const ResolveImageToImageOptions options = NO_OPTIONAL_OPERATION)
3019 : vkt::TestCase (testCtx, name, description)
3021 , m_options (options)
3023 virtual void initPrograms (SourceCollections& programCollection) const;
3025 virtual TestInstance* createInstance (Context& context) const
3027 return new ResolveImageToImage(context, m_params, m_options);
3030 TestParams m_params;
3031 const ResolveImageToImageOptions m_options;
3034 void ResolveImageToImageTestCase::initPrograms (SourceCollections& programCollection) const
3036 programCollection.glslSources.add("vert") << glu::VertexSource(
3038 "layout (location = 0) in highp vec4 a_position;\n"
3041 " gl_Position = a_position;\n"
3045 programCollection.glslSources.add("frag") << glu::FragmentSource(
3047 "layout (location = 0) out highp vec4 o_color;\n"
3050 " o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
3054 std::string getSampleCountCaseName (VkSampleCountFlagBits sampleFlag)
3056 return de::toLower(de::toString(getSampleCountFlagsStr(sampleFlag)).substr(16));
3059 std::string getFormatCaseName (VkFormat format)
3061 return de::toLower(de::toString(getFormatStr(format)).substr(10));
3064 void addCopyImageTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3065 tcu::TestContext& testCtx,
3068 const VkFormat compatibleFormats8Bit[] =
3070 VK_FORMAT_R4G4_UNORM_PACK8,
3073 VK_FORMAT_R8_USCALED,
3074 VK_FORMAT_R8_SSCALED,
3081 const VkFormat compatibleFormats16Bit[] =
3083 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3084 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3085 VK_FORMAT_R5G6B5_UNORM_PACK16,
3086 VK_FORMAT_B5G6R5_UNORM_PACK16,
3087 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3088 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3089 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3090 VK_FORMAT_R8G8_UNORM,
3091 VK_FORMAT_R8G8_SNORM,
3092 VK_FORMAT_R8G8_USCALED,
3093 VK_FORMAT_R8G8_SSCALED,
3094 VK_FORMAT_R8G8_UINT,
3095 VK_FORMAT_R8G8_SINT,
3096 VK_FORMAT_R8G8_SRGB,
3097 VK_FORMAT_R16_UNORM,
3098 VK_FORMAT_R16_SNORM,
3099 VK_FORMAT_R16_USCALED,
3100 VK_FORMAT_R16_SSCALED,
3103 VK_FORMAT_R16_SFLOAT,
3107 const VkFormat compatibleFormats24Bit[] =
3109 VK_FORMAT_R8G8B8_UNORM,
3110 VK_FORMAT_R8G8B8_SNORM,
3111 VK_FORMAT_R8G8B8_USCALED,
3112 VK_FORMAT_R8G8B8_SSCALED,
3113 VK_FORMAT_R8G8B8_UINT,
3114 VK_FORMAT_R8G8B8_SINT,
3115 VK_FORMAT_R8G8B8_SRGB,
3116 VK_FORMAT_B8G8R8_UNORM,
3117 VK_FORMAT_B8G8R8_SNORM,
3118 VK_FORMAT_B8G8R8_USCALED,
3119 VK_FORMAT_B8G8R8_SSCALED,
3120 VK_FORMAT_B8G8R8_UINT,
3121 VK_FORMAT_B8G8R8_SINT,
3122 VK_FORMAT_B8G8R8_SRGB,
3126 const VkFormat compatibleFormats32Bit[] =
3128 VK_FORMAT_R8G8B8A8_UNORM,
3129 VK_FORMAT_R8G8B8A8_SNORM,
3130 VK_FORMAT_R8G8B8A8_USCALED,
3131 VK_FORMAT_R8G8B8A8_SSCALED,
3132 VK_FORMAT_R8G8B8A8_UINT,
3133 VK_FORMAT_R8G8B8A8_SINT,
3134 VK_FORMAT_R8G8B8A8_SRGB,
3135 VK_FORMAT_B8G8R8A8_UNORM,
3136 VK_FORMAT_B8G8R8A8_SNORM,
3137 VK_FORMAT_B8G8R8A8_USCALED,
3138 VK_FORMAT_B8G8R8A8_SSCALED,
3139 VK_FORMAT_B8G8R8A8_UINT,
3140 VK_FORMAT_B8G8R8A8_SINT,
3141 VK_FORMAT_B8G8R8A8_SRGB,
3142 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3143 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3144 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3145 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3146 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3147 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3148 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3149 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3150 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3151 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3152 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3153 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3154 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3155 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3156 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3157 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3158 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3159 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3160 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3161 VK_FORMAT_R16G16_UNORM,
3162 VK_FORMAT_R16G16_SNORM,
3163 VK_FORMAT_R16G16_USCALED,
3164 VK_FORMAT_R16G16_SSCALED,
3165 VK_FORMAT_R16G16_UINT,
3166 VK_FORMAT_R16G16_SINT,
3167 VK_FORMAT_R16G16_SFLOAT,
3170 VK_FORMAT_R32_SFLOAT,
3174 const VkFormat compatibleFormats48Bit[] =
3176 VK_FORMAT_R16G16B16_UNORM,
3177 VK_FORMAT_R16G16B16_SNORM,
3178 VK_FORMAT_R16G16B16_USCALED,
3179 VK_FORMAT_R16G16B16_SSCALED,
3180 VK_FORMAT_R16G16B16_UINT,
3181 VK_FORMAT_R16G16B16_SINT,
3182 VK_FORMAT_R16G16B16_SFLOAT,
3186 const VkFormat compatibleFormats64Bit[] =
3188 VK_FORMAT_R16G16B16A16_UNORM,
3189 VK_FORMAT_R16G16B16A16_SNORM,
3190 VK_FORMAT_R16G16B16A16_USCALED,
3191 VK_FORMAT_R16G16B16A16_SSCALED,
3192 VK_FORMAT_R16G16B16A16_UINT,
3193 VK_FORMAT_R16G16B16A16_SINT,
3194 VK_FORMAT_R16G16B16A16_SFLOAT,
3195 VK_FORMAT_R32G32_UINT,
3196 VK_FORMAT_R32G32_SINT,
3197 VK_FORMAT_R32G32_SFLOAT,
3200 VK_FORMAT_R64_SFLOAT,
3204 const VkFormat compatibleFormats96Bit[] =
3206 VK_FORMAT_R32G32B32_UINT,
3207 VK_FORMAT_R32G32B32_SINT,
3208 VK_FORMAT_R32G32B32_SFLOAT,
3212 const VkFormat compatibleFormats128Bit[] =
3214 VK_FORMAT_R32G32B32A32_UINT,
3215 VK_FORMAT_R32G32B32A32_SINT,
3216 VK_FORMAT_R32G32B32A32_SFLOAT,
3217 VK_FORMAT_R64G64_UINT,
3218 VK_FORMAT_R64G64_SINT,
3219 VK_FORMAT_R64G64_SFLOAT,
3223 const VkFormat compatibleFormats192Bit[] =
3225 VK_FORMAT_R64G64B64_UINT,
3226 VK_FORMAT_R64G64B64_SINT,
3227 VK_FORMAT_R64G64B64_SFLOAT,
3231 const VkFormat compatibleFormats256Bit[] =
3233 VK_FORMAT_R64G64B64A64_UINT,
3234 VK_FORMAT_R64G64B64A64_SINT,
3235 VK_FORMAT_R64G64B64A64_SFLOAT,
3240 const VkFormat* colorImageFormatsToTest[] =
3242 compatibleFormats8Bit,
3243 compatibleFormats16Bit,
3244 compatibleFormats24Bit,
3245 compatibleFormats32Bit,
3246 compatibleFormats48Bit,
3247 compatibleFormats64Bit,
3248 compatibleFormats96Bit,
3249 compatibleFormats128Bit,
3250 compatibleFormats192Bit,
3251 compatibleFormats256Bit,
3253 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3255 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3257 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex];
3258 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3260 params.src.image.format = compatibleFormats[srcFormatIndex];
3261 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3263 params.dst.image.format = compatibleFormats[dstFormatIndex];
3265 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
3268 std::ostringstream testName;
3269 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3270 std::ostringstream description;
3271 description << "Copy from src " << params.src.image.format << " to dst " << params.dst.image.format;
3273 testCaseGroup->addChild(new CopyImageToImageTestCase(testCtx, testName.str(), description.str(), params));
3279 void addBlittingTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3280 tcu::TestContext& testCtx,
3283 // Test Image formats.
3284 const VkFormat compatibleFormatsUInts[] =
3287 VK_FORMAT_R8G8_UINT,
3288 VK_FORMAT_R8G8B8_UINT,
3289 VK_FORMAT_B8G8R8_UINT,
3290 VK_FORMAT_R8G8B8A8_UINT,
3291 VK_FORMAT_B8G8R8A8_UINT,
3292 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3293 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3294 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3296 VK_FORMAT_R16G16_UINT,
3297 VK_FORMAT_R16G16B16_UINT,
3298 VK_FORMAT_R16G16B16A16_UINT,
3300 VK_FORMAT_R32G32_UINT,
3301 VK_FORMAT_R32G32B32_UINT,
3302 VK_FORMAT_R32G32B32A32_UINT,
3304 VK_FORMAT_R64G64_UINT,
3305 VK_FORMAT_R64G64B64_UINT,
3306 VK_FORMAT_R64G64B64A64_UINT,
3310 const VkFormat compatibleFormatsSInts[] =
3313 VK_FORMAT_R8G8_SINT,
3314 VK_FORMAT_R8G8B8_SINT,
3315 VK_FORMAT_B8G8R8_SINT,
3316 VK_FORMAT_R8G8B8A8_SINT,
3317 VK_FORMAT_B8G8R8A8_SINT,
3318 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3319 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3320 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3322 VK_FORMAT_R16G16_SINT,
3323 VK_FORMAT_R16G16B16_SINT,
3324 VK_FORMAT_R16G16B16A16_SINT,
3326 VK_FORMAT_R32G32_SINT,
3327 VK_FORMAT_R32G32B32_SINT,
3328 VK_FORMAT_R32G32B32A32_SINT,
3330 VK_FORMAT_R64G64_SINT,
3331 VK_FORMAT_R64G64B64_SINT,
3332 VK_FORMAT_R64G64B64A64_SINT,
3336 const VkFormat compatibleFormatsFloats[] =
3338 VK_FORMAT_R4G4_UNORM_PACK8,
3339 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3340 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3341 VK_FORMAT_R5G6B5_UNORM_PACK16,
3342 VK_FORMAT_B5G6R5_UNORM_PACK16,
3343 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3344 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3345 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3348 VK_FORMAT_R8_USCALED,
3349 VK_FORMAT_R8_SSCALED,
3350 VK_FORMAT_R8G8_UNORM,
3351 VK_FORMAT_R8G8_SNORM,
3352 VK_FORMAT_R8G8_USCALED,
3353 VK_FORMAT_R8G8_SSCALED,
3354 VK_FORMAT_R8G8B8_UNORM,
3355 VK_FORMAT_R8G8B8_SNORM,
3356 VK_FORMAT_R8G8B8_USCALED,
3357 VK_FORMAT_R8G8B8_SSCALED,
3358 VK_FORMAT_B8G8R8_UNORM,
3359 VK_FORMAT_B8G8R8_SNORM,
3360 VK_FORMAT_B8G8R8_USCALED,
3361 VK_FORMAT_B8G8R8_SSCALED,
3362 VK_FORMAT_R8G8B8A8_UNORM,
3363 VK_FORMAT_R8G8B8A8_SNORM,
3364 VK_FORMAT_R8G8B8A8_USCALED,
3365 VK_FORMAT_R8G8B8A8_SSCALED,
3366 VK_FORMAT_B8G8R8A8_UNORM,
3367 VK_FORMAT_B8G8R8A8_SNORM,
3368 VK_FORMAT_B8G8R8A8_USCALED,
3369 VK_FORMAT_B8G8R8A8_SSCALED,
3370 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3371 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3372 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3373 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3374 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3375 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3376 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3377 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3378 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3379 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3380 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3381 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3382 VK_FORMAT_R16_UNORM,
3383 VK_FORMAT_R16_SNORM,
3384 VK_FORMAT_R16_USCALED,
3385 VK_FORMAT_R16_SSCALED,
3386 VK_FORMAT_R16_SFLOAT,
3387 VK_FORMAT_R16G16_UNORM,
3388 VK_FORMAT_R16G16_SNORM,
3389 VK_FORMAT_R16G16_USCALED,
3390 VK_FORMAT_R16G16_SSCALED,
3391 VK_FORMAT_R16G16_SFLOAT,
3392 VK_FORMAT_R16G16B16_UNORM,
3393 VK_FORMAT_R16G16B16_SNORM,
3394 VK_FORMAT_R16G16B16_USCALED,
3395 VK_FORMAT_R16G16B16_SSCALED,
3396 VK_FORMAT_R16G16B16_SFLOAT,
3397 VK_FORMAT_R16G16B16A16_UNORM,
3398 VK_FORMAT_R16G16B16A16_SNORM,
3399 VK_FORMAT_R16G16B16A16_USCALED,
3400 VK_FORMAT_R16G16B16A16_SSCALED,
3401 VK_FORMAT_R16G16B16A16_SFLOAT,
3402 VK_FORMAT_R32_SFLOAT,
3403 VK_FORMAT_R32G32_SFLOAT,
3404 VK_FORMAT_R32G32B32_SFLOAT,
3405 VK_FORMAT_R32G32B32A32_SFLOAT,
3406 VK_FORMAT_R64_SFLOAT,
3407 VK_FORMAT_R64G64_SFLOAT,
3408 VK_FORMAT_R64G64B64_SFLOAT,
3409 VK_FORMAT_R64G64B64A64_SFLOAT,
3410 // VK_FORMAT_B10G11R11_UFLOAT_PACK32,
3411 // VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
3412 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3413 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3414 // VK_FORMAT_BC2_UNORM_BLOCK,
3415 // VK_FORMAT_BC3_UNORM_BLOCK,
3416 // VK_FORMAT_BC4_UNORM_BLOCK,
3417 // VK_FORMAT_BC4_SNORM_BLOCK,
3418 // VK_FORMAT_BC5_UNORM_BLOCK,
3419 // VK_FORMAT_BC5_SNORM_BLOCK,
3420 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
3421 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
3422 // VK_FORMAT_BC7_UNORM_BLOCK,
3423 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3424 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3425 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3426 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
3427 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
3428 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3429 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3430 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3431 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3432 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3433 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3434 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3435 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3436 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3437 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3438 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3439 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3440 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3441 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3442 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3443 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3447 const VkFormat compatibleFormatsSrgb[] =
3450 VK_FORMAT_R8G8_SRGB,
3451 VK_FORMAT_R8G8B8_SRGB,
3452 VK_FORMAT_B8G8R8_SRGB,
3453 VK_FORMAT_R8G8B8A8_SRGB,
3454 VK_FORMAT_B8G8R8A8_SRGB,
3455 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3456 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3457 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3458 // VK_FORMAT_BC2_SRGB_BLOCK,
3459 // VK_FORMAT_BC3_SRGB_BLOCK,
3460 // VK_FORMAT_BC7_SRGB_BLOCK,
3461 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3462 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3463 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3464 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3465 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3466 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3467 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3468 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3469 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3470 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3471 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3472 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3473 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3474 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3475 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3476 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3477 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3483 const VkFormat* compatibleFormats;
3484 const bool onlyNearest;
3485 } colorImageFormatsToTest[] =
3487 { compatibleFormatsUInts, true },
3488 { compatibleFormatsSInts, true },
3489 { compatibleFormatsFloats, false },
3490 { compatibleFormatsSrgb, false },
3492 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3494 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3496 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex].compatibleFormats;
3497 const bool onlyNearest = colorImageFormatsToTest[compatibleFormatsIndex].onlyNearest;
3498 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3500 params.src.image.format = compatibleFormats[srcFormatIndex];
3501 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3503 params.dst.image.format = compatibleFormats[dstFormatIndex];
3505 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
3508 std::ostringstream testName;
3509 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3510 std::ostringstream description;
3511 description << "Blit image from src " << params.src.image.format << " to dst " << params.dst.image.format;
3513 params.filter = VK_FILTER_NEAREST;
3514 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_nearest", description.str(), params));
3518 params.filter = VK_FILTER_LINEAR;
3519 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_linear", description.str(), params));
3528 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
3530 de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
3532 de::MovePtr<tcu::TestCaseGroup> imageToImageTests (new tcu::TestCaseGroup(testCtx, "image_to_image", "Copy from image to image"));
3533 de::MovePtr<tcu::TestCaseGroup> imgToImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Copy from image to image simple tests"));
3534 de::MovePtr<tcu::TestCaseGroup> imgToImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Copy from image to image with all compatible formats"));
3535 de::MovePtr<tcu::TestCaseGroup> imgToImg3dImagesTests (new tcu::TestCaseGroup(testCtx, "3d_images", "Coping operations on 3d images"));
3537 de::MovePtr<tcu::TestCaseGroup> imageToBufferTests (new tcu::TestCaseGroup(testCtx, "image_to_buffer", "Copy from image to buffer"));
3538 de::MovePtr<tcu::TestCaseGroup> bufferToImageTests (new tcu::TestCaseGroup(testCtx, "buffer_to_image", "Copy from buffer to image"));
3539 de::MovePtr<tcu::TestCaseGroup> bufferToBufferTests (new tcu::TestCaseGroup(testCtx, "buffer_to_buffer", "Copy from buffer to buffer"));
3541 de::MovePtr<tcu::TestCaseGroup> blittingImageTests (new tcu::TestCaseGroup(testCtx, "blit_image", "Blitting image"));
3542 de::MovePtr<tcu::TestCaseGroup> blitImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Blitting image simple tests"));
3543 de::MovePtr<tcu::TestCaseGroup> blitImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Blitting image with all compatible formats"));
3545 de::MovePtr<tcu::TestCaseGroup> resolveImageTests (new tcu::TestCaseGroup(testCtx, "resolve_image", "Resolve image"));
3547 const deInt32 defaultSize = 64;
3548 const deInt32 defaultHalfSize = defaultSize / 2;
3549 const deInt32 defaultFourthSize = defaultSize / 4;
3550 const VkExtent3D defaultExtent = {defaultSize, defaultSize, 1};
3551 const VkExtent3D defaultHalfExtent = {defaultHalfSize, defaultHalfSize, 1};
3553 const VkImageSubresourceLayers defaultSourceLayer =
3555 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
3556 0u, // uint32_t mipLevel;
3557 0u, // uint32_t baseArrayLayer;
3558 1u, // uint32_t layerCount;
3561 const VkFormat depthAndStencilFormats[] =
3563 VK_FORMAT_D16_UNORM,
3564 VK_FORMAT_X8_D24_UNORM_PACK32,
3565 VK_FORMAT_D32_SFLOAT,
3567 VK_FORMAT_D16_UNORM_S8_UINT,
3568 VK_FORMAT_D24_UNORM_S8_UINT,
3569 VK_FORMAT_D32_SFLOAT_S8_UINT,
3572 // Copy image to image testcases.
3575 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3576 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3577 params.src.image.extent = defaultExtent;
3578 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3579 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3580 params.dst.image.extent = defaultExtent;
3583 const VkImageCopy testCopy =
3585 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3586 {0, 0, 0}, // VkOffset3D srcOffset;
3587 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3588 {0, 0, 0}, // VkOffset3D dstOffset;
3589 defaultExtent, // VkExtent3D extent;
3592 CopyRegion imageCopy;
3593 imageCopy.imageCopy = testCopy;
3595 params.regions.push_back(imageCopy);
3598 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image", "Whole image", params));
3603 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3604 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3605 params.src.image.extent = defaultExtent;
3606 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3607 params.dst.image.format = VK_FORMAT_R32_UINT;
3608 params.dst.image.extent = defaultExtent;
3611 const VkImageCopy testCopy =
3613 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3614 {0, 0, 0}, // VkOffset3D srcOffset;
3615 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3616 {0, 0, 0}, // VkOffset3D dstOffset;
3617 defaultExtent, // VkExtent3D extent;
3620 CopyRegion imageCopy;
3621 imageCopy.imageCopy = testCopy;
3623 params.regions.push_back(imageCopy);
3626 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image_diff_fromat", "Whole image with different format", params));
3631 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3632 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3633 params.src.image.extent = defaultExtent;
3634 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3635 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3636 params.dst.image.extent = defaultExtent;
3639 const VkImageCopy testCopy =
3641 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3642 {0, 0, 0}, // VkOffset3D srcOffset;
3643 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3644 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3645 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3648 CopyRegion imageCopy;
3649 imageCopy.imageCopy = testCopy;
3651 params.regions.push_back(imageCopy);
3654 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "partial_image", "Partial image", params));
3659 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3660 params.src.image.format = VK_FORMAT_D32_SFLOAT;
3661 params.src.image.extent = defaultExtent;
3662 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3663 params.dst.image.format = VK_FORMAT_D32_SFLOAT;
3664 params.dst.image.extent = defaultExtent;
3667 const VkImageSubresourceLayers sourceLayer =
3669 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
3670 0u, // uint32_t mipLevel;
3671 0u, // uint32_t baseArrayLayer;
3672 1u // uint32_t layerCount;
3674 const VkImageCopy testCopy =
3676 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3677 {0, 0, 0}, // VkOffset3D srcOffset;
3678 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3679 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3680 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3683 CopyRegion imageCopy;
3684 imageCopy.imageCopy = testCopy;
3686 params.regions.push_back(imageCopy);
3689 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "depth", "With depth", params));
3694 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3695 params.src.image.format = VK_FORMAT_S8_UINT;
3696 params.src.image.extent = defaultExtent;
3697 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3698 params.dst.image.format = VK_FORMAT_S8_UINT;
3699 params.dst.image.extent = defaultExtent;
3702 const VkImageSubresourceLayers sourceLayer =
3704 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
3705 0u, // uint32_t mipLevel;
3706 0u, // uint32_t baseArrayLayer;
3707 1u // uint32_t layerCount;
3709 const VkImageCopy testCopy =
3711 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3712 {0, 0, 0}, // VkOffset3D srcOffset;
3713 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3714 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3715 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3718 CopyRegion imageCopy;
3719 imageCopy.imageCopy = testCopy;
3721 params.regions.push_back(imageCopy);
3724 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "stencil", "With stencil", params));
3728 // Test Color formats.
3731 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3732 params.src.image.extent = defaultExtent;
3733 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3734 params.dst.image.extent = defaultExtent;
3736 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3738 const VkImageCopy testCopy =
3740 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3741 {0, 0, 0}, // VkOffset3D srcOffset;
3742 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3743 {i, defaultSize - i - defaultFourthSize, 0}, // VkOffset3D dstOffset;
3744 {defaultFourthSize, defaultFourthSize, 1}, // VkExtent3D extent;
3747 CopyRegion imageCopy;
3748 imageCopy.imageCopy = testCopy;
3750 params.regions.push_back(imageCopy);
3753 addCopyImageTestsAllFormats(imgToImgAllFormatsTests.get(), testCtx, params);
3756 // Test Depth and Stencil formats.
3758 const std::string description ("Copy image to image with depth/stencil formats ");
3759 const std::string testName ("depth_stencil");
3761 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
3765 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3766 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3767 params.src.image.extent = defaultExtent;
3768 params.dst.image.extent = defaultExtent;
3769 params.src.image.format = depthAndStencilFormats[compatibleFormatsIndex];
3770 params.dst.image.format = params.src.image.format;
3771 std::ostringstream oss;
3772 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3774 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
3775 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
3777 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3779 CopyRegion copyRegion;
3780 const VkOffset3D srcOffset = {0, 0, 0};
3781 const VkOffset3D dstOffset = {i, defaultSize - i - defaultFourthSize, 0};
3782 const VkExtent3D extent = {defaultFourthSize, defaultFourthSize, 1};
3784 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
3786 const VkImageCopy testCopy =
3788 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
3789 srcOffset, // VkOffset3D srcOffset;
3790 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
3791 dstOffset, // VkOffset3D dstOffset;
3792 extent, // VkExtent3D extent;
3795 copyRegion.imageCopy = testCopy;
3796 params.regions.push_back(copyRegion);
3798 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
3800 const VkImageCopy testCopy =
3802 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
3803 srcOffset, // VkOffset3D srcOffset;
3804 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
3805 dstOffset, // VkOffset3D dstOffset;
3806 extent, // VkExtent3D extent;
3809 copyRegion.imageCopy = testCopy;
3810 params.regions.push_back(copyRegion);
3814 imgToImgAllFormatsTests->addChild(new CopyImageToImageTestCase(testCtx, oss.str(), description, params));
3818 imageToImageTests->addChild(imgToImgSimpleTests.release());
3819 imageToImageTests->addChild(imgToImgAllFormatsTests.release());
3821 // Copy image to buffer testcases.
3824 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3825 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3826 params.src.image.extent = defaultExtent;
3827 params.dst.buffer.size = defaultSize * defaultSize;
3829 const VkBufferImageCopy bufferImageCopy =
3831 0u, // VkDeviceSize bufferOffset;
3832 0u, // uint32_t bufferRowLength;
3833 0u, // uint32_t bufferImageHeight;
3834 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3835 {0, 0, 0}, // VkOffset3D imageOffset;
3836 defaultExtent // VkExtent3D imageExtent;
3838 CopyRegion copyRegion;
3839 copyRegion.bufferImageCopy = bufferImageCopy;
3841 params.regions.push_back(copyRegion);
3843 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "whole", "Copy from image to buffer", params));
3848 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3849 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3850 params.src.image.extent = defaultExtent;
3851 params.dst.buffer.size = defaultSize * defaultSize;
3853 const VkBufferImageCopy bufferImageCopy =
3855 defaultSize * defaultHalfSize, // VkDeviceSize bufferOffset;
3856 0u, // uint32_t bufferRowLength;
3857 0u, // uint32_t bufferImageHeight;
3858 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3859 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3860 defaultHalfExtent // VkExtent3D imageExtent;
3862 CopyRegion copyRegion;
3863 copyRegion.bufferImageCopy = bufferImageCopy;
3865 params.regions.push_back(copyRegion);
3867 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "buffer_offset", "Copy from image to buffer with buffer offset", params));
3872 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3873 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3874 params.src.image.extent = defaultExtent;
3875 params.dst.buffer.size = defaultSize * defaultSize;
3877 const int pixelSize = tcu::getPixelSize(mapVkFormat(params.src.image.format));
3878 const VkDeviceSize bufferSize = pixelSize * params.dst.buffer.size;
3879 const VkDeviceSize offsetSize = pixelSize * defaultFourthSize * defaultFourthSize;
3880 deUint32 divisor = 1;
3881 for (VkDeviceSize offset = 0; offset < bufferSize - offsetSize; offset += offsetSize, ++divisor)
3883 const deUint32 bufferRowLength = defaultFourthSize;
3884 const deUint32 bufferImageHeight = defaultFourthSize;
3885 const VkExtent3D imageExtent = {defaultFourthSize / divisor, defaultFourthSize, 1};
3886 DE_ASSERT(!bufferRowLength || bufferRowLength >= imageExtent.width);
3887 DE_ASSERT(!bufferImageHeight || bufferImageHeight >= imageExtent.height);
3888 DE_ASSERT(imageExtent.width * imageExtent.height *imageExtent.depth <= offsetSize);
3891 const VkBufferImageCopy bufferImageCopy =
3893 offset, // VkDeviceSize bufferOffset;
3894 bufferRowLength, // uint32_t bufferRowLength;
3895 bufferImageHeight, // uint32_t bufferImageHeight;
3896 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3897 {0, 0, 0}, // VkOffset3D imageOffset;
3898 imageExtent // VkExtent3D imageExtent;
3900 region.bufferImageCopy = bufferImageCopy;
3901 params.regions.push_back(region);
3904 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "regions", "Copy from image to buffer with multiple regions", params));
3907 // Copy buffer to image testcases.
3910 params.src.buffer.size = defaultSize * defaultSize;
3911 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3912 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3913 params.dst.image.extent = defaultExtent;
3915 const VkBufferImageCopy bufferImageCopy =
3917 0u, // VkDeviceSize bufferOffset;
3918 0u, // uint32_t bufferRowLength;
3919 0u, // uint32_t bufferImageHeight;
3920 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3921 {0, 0, 0}, // VkOffset3D imageOffset;
3922 defaultExtent // VkExtent3D imageExtent;
3924 CopyRegion copyRegion;
3925 copyRegion.bufferImageCopy = bufferImageCopy;
3927 params.regions.push_back(copyRegion);
3929 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "whole", "Copy from buffer to image", params));
3934 params.src.buffer.size = defaultSize * defaultSize;
3935 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3936 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3937 params.dst.image.extent = defaultExtent;
3940 deUint32 divisor = 1;
3941 for (int offset = 0; (offset + defaultFourthSize / divisor < defaultSize) && (defaultFourthSize > divisor); offset += defaultFourthSize / divisor++)
3943 const VkBufferImageCopy bufferImageCopy =
3945 0u, // VkDeviceSize bufferOffset;
3946 0u, // uint32_t bufferRowLength;
3947 0u, // uint32_t bufferImageHeight;
3948 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3949 {offset, defaultHalfSize, 0}, // VkOffset3D imageOffset;
3950 {defaultFourthSize / divisor, defaultFourthSize / divisor, 1} // VkExtent3D imageExtent;
3952 region.bufferImageCopy = bufferImageCopy;
3953 params.regions.push_back(region);
3956 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "regions", "Copy from buffer to image with multiple regions", params));
3961 params.src.buffer.size = defaultSize * defaultSize;
3962 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3963 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3964 params.dst.image.extent = defaultExtent;
3966 const VkBufferImageCopy bufferImageCopy =
3968 defaultFourthSize, // VkDeviceSize bufferOffset;
3969 defaultHalfSize + defaultFourthSize, // uint32_t bufferRowLength;
3970 defaultHalfSize + defaultFourthSize, // uint32_t bufferImageHeight;
3971 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3972 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3973 defaultHalfExtent // VkExtent3D imageExtent;
3975 CopyRegion copyRegion;
3976 copyRegion.bufferImageCopy = bufferImageCopy;
3978 params.regions.push_back(copyRegion);
3980 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_offset", "Copy from buffer to image with buffer offset", params));
3983 // Copy buffer to buffer testcases.
3986 params.src.buffer.size = defaultSize;
3987 params.dst.buffer.size = defaultSize;
3989 const VkBufferCopy bufferCopy =
3991 0u, // VkDeviceSize srcOffset;
3992 0u, // VkDeviceSize dstOffset;
3993 defaultSize, // VkDeviceSize size;
3996 CopyRegion copyRegion;
3997 copyRegion.bufferCopy = bufferCopy;
3998 params.regions.push_back(copyRegion);
4000 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
4005 params.src.buffer.size = defaultFourthSize;
4006 params.dst.buffer.size = defaultFourthSize;
4008 const VkBufferCopy bufferCopy =
4010 12u, // VkDeviceSize srcOffset;
4011 4u, // VkDeviceSize dstOffset;
4012 1u, // VkDeviceSize size;
4015 CopyRegion copyRegion;
4016 copyRegion.bufferCopy = bufferCopy;
4017 params.regions.push_back(copyRegion);
4019 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "partial", "Partial", params));
4023 const deUint32 size = 16;
4025 params.src.buffer.size = size;
4026 params.dst.buffer.size = size * (size + 1);
4028 // Copy region with size 1..size
4029 for (unsigned int i = 1; i <= size; i++)
4031 const VkBufferCopy bufferCopy =
4033 0, // VkDeviceSize srcOffset;
4034 i * size, // VkDeviceSize dstOffset;
4035 i, // VkDeviceSize size;
4038 CopyRegion copyRegion;
4039 copyRegion.bufferCopy = bufferCopy;
4040 params.regions.push_back(copyRegion);
4043 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "regions", "Multiple regions", params));
4046 // Blitting testcases.
4048 const std::string description ("Blit without scaling (whole)");
4049 const std::string testName ("whole");
4052 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4053 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4054 params.src.image.extent = defaultExtent;
4055 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4056 params.dst.image.extent = defaultExtent;
4059 const VkImageBlit imageBlit =
4061 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4064 {defaultSize, defaultSize, 1}
4065 }, // VkOffset3D srcOffsets[2];
4067 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4070 {defaultSize, defaultSize, 1}
4071 } // VkOffset3D dstOffset[2];
4075 region.imageBlit = imageBlit;
4076 params.regions.push_back(region);
4079 // Filter is VK_FILTER_NEAREST.
4081 params.filter = VK_FILTER_NEAREST;
4083 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4084 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4086 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4087 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4088 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4090 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4091 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4092 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4095 // Filter is VK_FILTER_LINEAR.
4097 params.filter = VK_FILTER_LINEAR;
4099 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4100 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4102 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4103 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4104 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4106 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4107 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4108 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4113 const std::string description ("Flipping x and y coordinates (whole)");
4114 const std::string testName ("mirror_xy");
4117 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4118 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4119 params.src.image.extent = defaultExtent;
4120 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4121 params.dst.image.extent = defaultExtent;
4124 const VkImageBlit imageBlit =
4126 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4129 {defaultSize, defaultSize, 1}
4130 }, // VkOffset3D srcOffsets[2];
4132 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4134 {defaultSize, defaultSize, 0},
4136 } // VkOffset3D dstOffset[2];
4140 region.imageBlit = imageBlit;
4141 params.regions.push_back(region);
4144 // Filter is VK_FILTER_NEAREST.
4146 params.filter = VK_FILTER_NEAREST;
4148 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4149 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4151 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4152 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4153 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4155 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4156 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4157 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4160 // Filter is VK_FILTER_LINEAR.
4162 params.filter = VK_FILTER_LINEAR;
4164 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4165 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4167 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4168 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4169 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4171 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4172 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4173 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4178 const std::string description ("Flipping x coordinates (whole)");
4179 const std::string testName ("mirror_x");
4182 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4183 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4184 params.src.image.extent = defaultExtent;
4185 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4186 params.dst.image.extent = defaultExtent;
4189 const VkImageBlit imageBlit =
4191 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4194 {defaultSize, defaultSize, 1}
4195 }, // VkOffset3D srcOffsets[2];
4197 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4199 {defaultSize, 0, 0},
4201 } // VkOffset3D dstOffset[2];
4205 region.imageBlit = imageBlit;
4206 params.regions.push_back(region);
4209 // Filter is VK_FILTER_NEAREST.
4211 params.filter = VK_FILTER_NEAREST;
4213 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4214 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4216 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4217 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4218 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4220 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4221 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4222 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4225 // Filter is VK_FILTER_LINEAR.
4227 params.filter = VK_FILTER_LINEAR;
4229 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4230 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4232 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4233 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4234 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4236 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4237 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4238 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4243 const std::string description ("Flipping Y coordinates (whole)");
4244 const std::string testName ("mirror_y");
4247 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4248 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4249 params.src.image.extent = defaultExtent;
4250 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4251 params.dst.image.extent = defaultExtent;
4254 const VkImageBlit imageBlit =
4256 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4259 {defaultSize, defaultSize, 1}
4260 }, // VkOffset3D srcOffsets[2];
4262 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4264 {0, defaultSize, 0},
4266 } // VkOffset3D dstOffset[2];
4270 region.imageBlit = imageBlit;
4271 params.regions.push_back(region);
4274 // Filter is VK_FILTER_NEAREST.
4276 params.filter = VK_FILTER_NEAREST;
4278 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4279 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4281 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4282 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4283 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4285 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4286 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4287 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4290 // Filter is VK_FILTER_LINEAR.
4292 params.filter = VK_FILTER_LINEAR;
4294 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4295 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4297 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4298 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4299 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4301 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4302 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4303 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4308 const std::string description ("Mirroring subregions in image (no flip ,y flip ,x flip, xy flip)");
4309 const std::string testName ("mirror_subregions");
4312 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4313 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4314 params.src.image.extent = defaultExtent;
4315 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4316 params.dst.image.extent = defaultExtent;
4320 const VkImageBlit imageBlit =
4322 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4325 {defaultHalfSize, defaultHalfSize, 1}
4326 }, // VkOffset3D srcOffsets[2];
4328 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4331 {defaultHalfSize, defaultHalfSize, 1}
4332 } // VkOffset3D dstOffset[2];
4336 region.imageBlit = imageBlit;
4337 params.regions.push_back(region);
4340 // Flipping y coordinates.
4342 const VkImageBlit imageBlit =
4344 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4346 {defaultHalfSize, 0, 0},
4347 {defaultSize, defaultHalfSize, 1}
4348 }, // VkOffset3D srcOffsets[2];
4350 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4352 {defaultHalfSize, defaultHalfSize, 0},
4354 } // VkOffset3D dstOffset[2];
4358 region.imageBlit = imageBlit;
4359 params.regions.push_back(region);
4362 // Flipping x coordinates.
4364 const VkImageBlit imageBlit =
4366 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4368 {0, defaultHalfSize, 0},
4369 {defaultHalfSize, defaultSize, 1}
4370 }, // VkOffset3D srcOffsets[2];
4372 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4374 {defaultHalfSize, defaultHalfSize, 0},
4376 } // VkOffset3D dstOffset[2];
4380 region.imageBlit = imageBlit;
4381 params.regions.push_back(region);
4384 // Flipping x and y coordinates.
4386 const VkImageBlit imageBlit =
4388 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4390 {defaultHalfSize, defaultHalfSize, 0},
4391 {defaultSize, defaultSize, 1}
4392 }, // VkOffset3D srcOffsets[2];
4394 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4396 {defaultSize, defaultSize, 0},
4397 {defaultHalfSize, defaultHalfSize, 1}
4398 } // VkOffset3D dstOffset[2];
4402 region.imageBlit = imageBlit;
4403 params.regions.push_back(region);
4406 // Filter is VK_FILTER_NEAREST.
4408 params.filter = VK_FILTER_NEAREST;
4410 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4411 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4413 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4414 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4415 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4417 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4418 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4419 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4422 // Filter is VK_FILTER_LINEAR.
4424 params.filter = VK_FILTER_LINEAR;
4426 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4427 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4429 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4430 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4431 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4433 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4434 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4435 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4440 const std::string description ("Blit with scaling (whole, src extent bigger)");
4441 const std::string testName ("scaling_whole1");
4444 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4445 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4446 params.src.image.extent = defaultExtent;
4447 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4448 params.dst.image.extent = defaultHalfExtent;
4451 const VkImageBlit imageBlit =
4453 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4456 {defaultSize, defaultSize, 1}
4457 }, // VkOffset3D srcOffsets[2];
4459 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4462 {defaultHalfSize, defaultHalfSize, 1}
4463 } // VkOffset3D dstOffset[2];
4467 region.imageBlit = imageBlit;
4468 params.regions.push_back(region);
4471 // Filter is VK_FILTER_NEAREST.
4473 params.filter = VK_FILTER_NEAREST;
4475 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4476 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4478 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4479 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4480 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4482 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4483 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4484 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4487 // Filter is VK_FILTER_LINEAR.
4489 params.filter = VK_FILTER_LINEAR;
4491 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4492 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4494 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4495 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4496 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4498 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4499 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4500 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4505 const std::string description ("Blit with scaling (whole, dst extent bigger)");
4506 const std::string testName ("scaling_whole2");
4509 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4510 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4511 params.src.image.extent = defaultHalfExtent;
4512 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4513 params.dst.image.extent = defaultExtent;
4516 const VkImageBlit imageBlit =
4518 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4521 {defaultHalfSize, defaultHalfSize, 1}
4522 }, // VkOffset3D srcOffsets[2];
4524 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4527 {defaultSize, defaultSize, 1}
4528 } // VkOffset3D dstOffset[2];
4532 region.imageBlit = imageBlit;
4533 params.regions.push_back(region);
4536 // Filter is VK_FILTER_NEAREST.
4538 params.filter = VK_FILTER_NEAREST;
4540 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4541 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4543 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4544 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4545 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4547 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4548 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4549 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4552 // Filter is VK_FILTER_LINEAR.
4554 params.filter = VK_FILTER_LINEAR;
4556 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4557 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4559 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4560 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4561 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4563 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4564 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4565 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4570 const std::string description ("Blit with scaling and offset (whole, dst extent bigger)");
4571 const std::string testName ("scaling_and_offset");
4574 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4575 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4576 params.src.image.extent = defaultExtent;
4577 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4578 params.dst.image.extent = defaultExtent;
4581 const VkImageBlit imageBlit =
4583 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4585 {defaultFourthSize, defaultFourthSize, 0},
4586 {defaultFourthSize*3, defaultFourthSize*3, 1}
4587 }, // VkOffset3D srcOffsets[2];
4589 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4592 {defaultSize, defaultSize, 1}
4593 } // VkOffset3D dstOffset[2];
4597 region.imageBlit = imageBlit;
4598 params.regions.push_back(region);
4601 // Filter is VK_FILTER_NEAREST.
4603 params.filter = VK_FILTER_NEAREST;
4605 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4606 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4608 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4609 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4610 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4612 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4613 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4614 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4617 // Filter is VK_FILTER_LINEAR.
4619 params.filter = VK_FILTER_LINEAR;
4621 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4622 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4624 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4625 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4626 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4628 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4629 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4630 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4635 const std::string description ("Blit without scaling (partial)");
4636 const std::string testName ("without_scaling_partial");
4639 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4640 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4641 params.src.image.extent = defaultExtent;
4642 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4643 params.dst.image.extent = defaultExtent;
4647 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4649 const VkImageBlit imageBlit =
4651 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4653 {defaultSize - defaultFourthSize - i, defaultSize - defaultFourthSize - i, 0},
4654 {defaultSize - i, defaultSize - i, 1}
4655 }, // VkOffset3D srcOffsets[2];
4657 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4660 {i + defaultFourthSize, i + defaultFourthSize, 1}
4661 } // VkOffset3D dstOffset[2];
4663 region.imageBlit = imageBlit;
4664 params.regions.push_back(region);
4668 // Filter is VK_FILTER_NEAREST.
4670 params.filter = VK_FILTER_NEAREST;
4672 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4673 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4676 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4677 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4678 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4680 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4681 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4682 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4685 // Filter is VK_FILTER_LINEAR.
4687 params.filter = VK_FILTER_LINEAR;
4689 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4690 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4692 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4693 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4694 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4696 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4697 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4698 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4703 const std::string description ("Blit with scaling (partial)");
4704 const std::string testName ("scaling_partial");
4706 // Test Color formats.
4709 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4710 params.src.image.extent = defaultExtent;
4711 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4712 params.dst.image.extent = defaultExtent;
4715 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4717 const VkImageBlit imageBlit =
4719 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4722 {defaultSize, defaultSize, 1}
4723 }, // VkOffset3D srcOffsets[2];
4725 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4728 {i + defaultFourthSize / j, defaultFourthSize / j, 1}
4729 } // VkOffset3D dstOffset[2];
4731 region.imageBlit = imageBlit;
4732 params.regions.push_back(region);
4734 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4736 const VkImageBlit imageBlit =
4738 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4741 {i + defaultFourthSize, i + defaultFourthSize, 1}
4742 }, // VkOffset3D srcOffsets[2];
4744 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4746 {i, defaultSize / 2, 0},
4747 {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1}
4748 } // VkOffset3D dstOffset[2];
4750 region.imageBlit = imageBlit;
4751 params.regions.push_back(region);
4754 addBlittingTestsAllFormats(blitImgAllFormatsTests.get(), testCtx, params);
4757 // Test Depth and Stencil formats.
4759 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
4763 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4764 params.src.image.extent = defaultExtent;
4765 params.dst.image.extent = defaultExtent;
4766 params.src.image.format = depthAndStencilFormats[compatibleFormatsIndex];
4767 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4768 params.dst.image.format = params.src.image.format;
4769 std::ostringstream oss;
4770 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
4772 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
4773 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
4776 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4778 const VkOffset3D srcOffset0 = {0, 0, 0};
4779 const VkOffset3D srcOffset1 = {defaultSize, defaultSize, 1};
4780 const VkOffset3D dstOffset0 = {i, 0, 0};
4781 const VkOffset3D dstOffset1 = {i + defaultFourthSize / j, defaultFourthSize / j, 1};
4783 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4785 const VkImageBlit imageBlit =
4787 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4788 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4789 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4790 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4792 region.imageBlit = imageBlit;
4793 params.regions.push_back(region);
4795 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4797 const VkImageBlit imageBlit =
4799 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4800 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4801 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4802 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4804 region.imageBlit = imageBlit;
4805 params.regions.push_back(region);
4808 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4810 const VkOffset3D srcOffset0 = {i, i, 0};
4811 const VkOffset3D srcOffset1 = {i + defaultFourthSize, i + defaultFourthSize, 1};
4812 const VkOffset3D dstOffset0 = {i, defaultSize / 2, 0};
4813 const VkOffset3D dstOffset1 = {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1};
4815 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4817 const VkImageBlit imageBlit =
4819 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4820 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4821 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4822 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4824 region.imageBlit = imageBlit;
4825 params.regions.push_back(region);
4827 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4829 const VkImageBlit imageBlit =
4831 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4832 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4833 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4834 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4836 region.imageBlit = imageBlit;
4837 params.regions.push_back(region);
4841 params.filter = VK_FILTER_NEAREST;
4842 blitImgAllFormatsTests->addChild(new BlittingTestCase(testCtx, oss.str() + "_nearest", description, params));
4846 blittingImageTests->addChild(blitImgSimpleTests.release());
4847 blittingImageTests->addChild(blitImgAllFormatsTests.release());
4849 // Resolve image to image testcases.
4850 const VkSampleCountFlagBits samples[] =
4852 VK_SAMPLE_COUNT_2_BIT,
4853 VK_SAMPLE_COUNT_4_BIT,
4854 VK_SAMPLE_COUNT_8_BIT,
4855 VK_SAMPLE_COUNT_16_BIT,
4856 VK_SAMPLE_COUNT_32_BIT,
4857 VK_SAMPLE_COUNT_64_BIT
4859 const VkExtent3D resolveExtent = {256u, 256u, 1};
4862 const std::string description ("Resolve from image to image");
4863 const std::string testName ("whole");
4866 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4867 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4868 params.src.image.extent = resolveExtent;
4869 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4870 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4871 params.dst.image.extent = resolveExtent;
4874 const VkImageSubresourceLayers sourceLayer =
4876 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4877 0u, // uint32_t mipLevel;
4878 0u, // uint32_t baseArrayLayer;
4879 1u // uint32_t layerCount;
4881 const VkImageResolve testResolve =
4883 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4884 {0, 0, 0}, // VkOffset3D srcOffset;
4885 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4886 {0, 0, 0}, // VkOffset3D dstOffset;
4887 resolveExtent, // VkExtent3D extent;
4890 CopyRegion imageResolve;
4891 imageResolve.imageResolve = testResolve;
4892 params.regions.push_back(imageResolve);
4895 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4897 params.samples = samples[samplesIndex];
4898 std::ostringstream caseName;
4899 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4900 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4905 const std::string description ("Resolve from image to image");
4906 const std::string testName ("partial");
4909 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4910 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4911 params.src.image.extent = resolveExtent;
4912 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4913 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4914 params.dst.image.extent = resolveExtent;
4917 const VkImageSubresourceLayers sourceLayer =
4919 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4920 0u, // uint32_t mipLevel;
4921 0u, // uint32_t baseArrayLayer;
4922 1u // uint32_t layerCount;
4924 const VkImageResolve testResolve =
4926 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4927 {0, 0, 0}, // VkOffset3D srcOffset;
4928 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4929 {64u, 64u, 0}, // VkOffset3D dstOffset;
4930 {128u, 128u, 1u}, // VkExtent3D extent;
4933 CopyRegion imageResolve;
4934 imageResolve.imageResolve = testResolve;
4935 params.regions.push_back(imageResolve);
4938 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4940 params.samples = samples[samplesIndex];
4941 std::ostringstream caseName;
4942 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4943 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4948 const std::string description ("Resolve from image to image");
4949 const std::string testName ("with_regions");
4952 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4953 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4954 params.src.image.extent = resolveExtent;
4955 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4956 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4957 params.dst.image.extent = resolveExtent;
4960 const VkImageSubresourceLayers sourceLayer =
4962 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4963 0u, // uint32_t mipLevel;
4964 0u, // uint32_t baseArrayLayer;
4965 1u // uint32_t layerCount;
4968 for (int i = 0; i < 256; i += 64)
4970 const VkImageResolve testResolve =
4972 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4973 {i, i, 0}, // VkOffset3D srcOffset;
4974 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4975 {i, 0, 0}, // VkOffset3D dstOffset;
4976 {64u, 64u, 1u}, // VkExtent3D extent;
4979 CopyRegion imageResolve;
4980 imageResolve.imageResolve = testResolve;
4981 params.regions.push_back(imageResolve);
4985 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4987 params.samples = samples[samplesIndex];
4988 std::ostringstream caseName;
4989 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4990 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4995 const std::string description ("Resolve from image to image");
4996 const std::string testName ("whole_copy_before_resolving");
4999 params.src.image.imageType = VK_IMAGE_TYPE_2D;
5000 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5001 params.src.image.extent = defaultExtent;
5002 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
5003 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5004 params.dst.image.extent = defaultExtent;
5007 const VkImageSubresourceLayers sourceLayer =
5009 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5010 0u, // uint32_t mipLevel;
5011 0u, // uint32_t baseArrayLayer;
5012 1u // uint32_t layerCount;
5015 const VkImageResolve testResolve =
5017 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5018 {0, 0, 0}, // VkOffset3D srcOffset;
5019 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5020 {0, 0, 0}, // VkOffset3D dstOffset;
5021 defaultExtent, // VkExtent3D extent;
5024 CopyRegion imageResolve;
5025 imageResolve.imageResolve = testResolve;
5026 params.regions.push_back(imageResolve);
5029 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
5031 params.samples = samples[samplesIndex];
5032 std::ostringstream caseName;
5033 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
5034 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_MS_IMAGE));
5039 const std::string description ("Resolve from image to image");
5040 const std::string testName ("whole_array_image");
5043 params.src.image.imageType = VK_IMAGE_TYPE_2D;
5044 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5045 params.src.image.extent = defaultExtent;
5046 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
5047 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5048 params.dst.image.extent = defaultExtent;
5049 params.dst.image.extent.depth = 5u;
5051 for (deUint32 layerNdx=0; layerNdx < params.dst.image.extent.depth; ++layerNdx)
5053 const VkImageSubresourceLayers sourceLayer =
5055 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5056 0u, // uint32_t mipLevel;
5057 layerNdx, // uint32_t baseArrayLayer;
5058 1u // uint32_t layerCount;
5061 const VkImageResolve testResolve =
5063 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5064 {0, 0, 0}, // VkOffset3D srcOffset;
5065 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5066 {0, 0, 0}, // VkOffset3D dstOffset;
5067 defaultExtent, // VkExtent3D extent;
5070 CopyRegion imageResolve;
5071 imageResolve.imageResolve = testResolve;
5072 params.regions.push_back(imageResolve);
5075 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
5077 params.samples = samples[samplesIndex];
5078 std::ostringstream caseName;
5079 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
5080 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE));
5085 TestParams params3DTo2D;
5086 const deUint32 slicesLayers = 16u;
5087 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5088 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5089 params3DTo2D.src.image.extent = defaultHalfExtent;
5090 params3DTo2D.src.image.extent.depth = slicesLayers;
5091 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5092 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5093 params3DTo2D.dst.image.extent = defaultHalfExtent;
5094 params3DTo2D.dst.image.extent.depth = slicesLayers;
5096 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5098 const VkImageSubresourceLayers sourceLayer =
5100 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5101 0u, // uint32_t mipLevel;
5102 0u, // uint32_t baseArrayLayer;
5103 1u // uint32_t layerCount;
5106 const VkImageSubresourceLayers destinationLayer =
5108 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5109 0u, // uint32_t mipLevel;
5110 slicesLayersNdx, // uint32_t baseArrayLayer;
5111 1u // uint32_t layerCount;
5114 const VkImageCopy testCopy =
5116 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5117 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
5118 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5119 {0, 0, 0}, // VkOffset3D dstOffset;
5120 defaultHalfExtent, // VkExtent3D extent;
5123 CopyRegion imageCopy;
5124 imageCopy.imageCopy = testCopy;
5126 params3DTo2D.regions.push_back(imageCopy);
5128 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
5132 TestParams params2DTo3D;
5133 const deUint32 slicesLayers = 16u;
5134 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5135 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5136 params2DTo3D.src.image.extent = defaultHalfExtent;
5137 params2DTo3D.src.image.extent.depth = slicesLayers;
5138 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5139 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5140 params2DTo3D.dst.image.extent = defaultHalfExtent;
5141 params2DTo3D.dst.image.extent.depth = slicesLayers;
5143 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5145 const VkImageSubresourceLayers sourceLayer =
5147 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5148 0u, // uint32_t mipLevel;
5149 slicesLayersNdx, // uint32_t baseArrayLayer;
5150 1u // uint32_t layerCount;
5153 const VkImageSubresourceLayers destinationLayer =
5155 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5156 0u, // uint32_t mipLevel;
5157 0u, // uint32_t baseArrayLayer;
5158 1u // uint32_t layerCount;
5161 const VkImageCopy testCopy =
5163 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5164 {0, 0, 0}, // VkOffset3D srcOffset;
5165 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5166 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D dstOffset;
5167 defaultHalfExtent, // VkExtent3D extent;
5170 CopyRegion imageCopy;
5171 imageCopy.imageCopy = testCopy;
5173 params2DTo3D.regions.push_back(imageCopy);
5176 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
5180 TestParams params3DTo2D;
5181 const deUint32 slicesLayers = 16u;
5182 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5183 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5184 params3DTo2D.src.image.extent = defaultHalfExtent;
5185 params3DTo2D.src.image.extent.depth = slicesLayers;
5186 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5187 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5188 params3DTo2D.dst.image.extent = defaultHalfExtent;
5189 params3DTo2D.dst.image.extent.depth = slicesLayers;
5192 const VkImageSubresourceLayers sourceLayer =
5194 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5195 0u, // uint32_t mipLevel;
5196 0u, // uint32_t baseArrayLayer;
5197 1u // uint32_t layerCount;
5200 const VkImageSubresourceLayers destinationLayer =
5202 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5203 0u, // uint32_t mipLevel;
5204 0, // uint32_t baseArrayLayer;
5205 slicesLayers // uint32_t layerCount;
5208 const VkImageCopy testCopy =
5210 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5211 {0, 0, 0}, // VkOffset3D srcOffset;
5212 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5213 {0, 0, 0}, // VkOffset3D dstOffset;
5214 params3DTo2D.src.image.extent // VkExtent3D extent;
5217 CopyRegion imageCopy;
5218 imageCopy.imageCopy = testCopy;
5220 params3DTo2D.regions.push_back(imageCopy);
5222 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
5226 TestParams params2DTo3D;
5227 const deUint32 slicesLayers = 16u;
5228 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5229 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5230 params2DTo3D.src.image.extent = defaultHalfExtent;
5231 params2DTo3D.src.image.extent.depth = slicesLayers;
5232 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5233 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5234 params2DTo3D.dst.image.extent = defaultHalfExtent;
5235 params2DTo3D.dst.image.extent.depth = slicesLayers;
5238 const VkImageSubresourceLayers sourceLayer =
5240 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5241 0u, // uint32_t mipLevel;
5242 0u, // uint32_t baseArrayLayer;
5243 slicesLayers // uint32_t layerCount;
5246 const VkImageSubresourceLayers destinationLayer =
5248 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5249 0u, // uint32_t mipLevel;
5250 0u, // uint32_t baseArrayLayer;
5251 1u // uint32_t layerCount;
5254 const VkImageCopy testCopy =
5256 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5257 {0, 0, 0}, // VkOffset3D srcOffset;
5258 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5259 {0, 0, 0}, // VkOffset3D dstOffset;
5260 params2DTo3D.dst.image.extent, // VkExtent3D extent;
5263 CopyRegion imageCopy;
5264 imageCopy.imageCopy = testCopy;
5266 params2DTo3D.regions.push_back(imageCopy);
5269 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
5273 TestParams params3DTo2D;
5274 const deUint32 slicesLayers = 16u;
5275 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5276 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5277 params3DTo2D.src.image.extent = defaultHalfExtent;
5278 params3DTo2D.src.image.extent.depth = slicesLayers;
5279 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5280 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5281 params3DTo2D.dst.image.extent = defaultHalfExtent;
5282 params3DTo2D.dst.image.extent.depth = slicesLayers;
5284 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5285 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5287 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5289 const VkImageSubresourceLayers sourceLayer =
5291 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5292 0u, // uint32_t mipLevel;
5293 0u, // uint32_t baseArrayLayer;
5294 1u // uint32_t layerCount;
5297 const VkImageSubresourceLayers destinationLayer =
5299 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5300 0u, // uint32_t mipLevel;
5301 slicesLayersNdx, // uint32_t baseArrayLayer;
5302 1u // uint32_t layerCount;
5306 const VkImageCopy testCopy =
5308 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5309 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
5310 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5311 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D dstOffset;
5313 (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
5314 (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
5316 } // VkExtent3D extent;
5319 CopyRegion imageCopy;
5320 imageCopy.imageCopy = testCopy;
5321 params3DTo2D.regions.push_back(imageCopy);
5323 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
5327 TestParams params2DTo3D;
5328 const deUint32 slicesLayers = 16u;
5329 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5330 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5331 params2DTo3D.src.image.extent = defaultHalfExtent;
5332 params2DTo3D.src.image.extent.depth = slicesLayers;
5333 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5334 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5335 params2DTo3D.dst.image.extent = defaultHalfExtent;
5336 params2DTo3D.dst.image.extent.depth = slicesLayers;
5338 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5339 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5341 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5343 const VkImageSubresourceLayers sourceLayer =
5345 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5346 0u, // uint32_t mipLevel;
5347 slicesLayersNdx, // uint32_t baseArrayLayer;
5348 1u // uint32_t layerCount;
5351 const VkImageSubresourceLayers destinationLayer =
5353 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5354 0u, // uint32_t mipLevel;
5355 0u, // uint32_t baseArrayLayer;
5356 1u // uint32_t layerCount;
5359 const VkImageCopy testCopy =
5361 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5362 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D srcOffset;
5363 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5364 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)(slicesLayersNdx)}, // VkOffset3D dstOffset;
5366 defaultHalfExtent.width - regionWidth*slicesLayersNdx,
5367 defaultHalfExtent.height - regionHeight*slicesLayersNdx,
5369 } // VkExtent3D extent;
5372 CopyRegion imageCopy;
5373 imageCopy.imageCopy = testCopy;
5375 params2DTo3D.regions.push_back(imageCopy);
5378 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
5381 imageToImageTests->addChild(imgToImg3dImagesTests.release());
5383 copiesAndBlittingTests->addChild(imageToImageTests.release());
5384 copiesAndBlittingTests->addChild(imageToBufferTests.release());
5385 copiesAndBlittingTests->addChild(bufferToImageTests.release());
5386 copiesAndBlittingTests->addChild(bufferToBufferTests.release());
5387 copiesAndBlittingTests->addChild(blittingImageTests.release());
5388 copiesAndBlittingTests->addChild(resolveImageTests.release());
5390 return copiesAndBlittingTests.release();