1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015-2016 The Khronos Group Inc.
6 * Copyright (c) 2015-2016 Samsung Electronics Co., Ltd.
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
22 * \brief Vulkan Copies And Blitting Tests
23 *//*--------------------------------------------------------------------*/
25 #include "vktApiCopiesAndBlittingTests.hpp"
27 #include "deStringUtil.hpp"
28 #include "deUniquePtr.hpp"
30 #include "tcuImageCompare.hpp"
31 #include "tcuTexture.hpp"
32 #include "tcuTextureUtil.hpp"
33 #include "tcuVectorType.hpp"
34 #include "tcuVectorUtil.hpp"
36 #include "vkImageUtil.hpp"
37 #include "vkMemUtil.hpp"
38 #include "vkPrograms.hpp"
39 #include "vkQueryUtil.hpp"
40 #include "vkRefUtil.hpp"
41 #include "vktTestCase.hpp"
42 #include "vktTestCaseUtil.hpp"
43 #include "vkTypeUtil.hpp"
56 MIRROR_MODE_X = (1<<0),
57 MIRROR_MODE_Y = (1<<1),
58 MIRROR_MODE_XY = MIRROR_MODE_X | MIRROR_MODE_Y,
70 VkImageAspectFlags getAspectFlags (tcu::TextureFormat format)
72 VkImageAspectFlags aspectFlag = 0;
73 aspectFlag |= (tcu::hasDepthComponent(format.order)? VK_IMAGE_ASPECT_DEPTH_BIT : 0);
74 aspectFlag |= (tcu::hasStencilComponent(format.order)? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
77 aspectFlag = VK_IMAGE_ASPECT_COLOR_BIT;
82 // This is effectively same as vk::isFloatFormat(mapTextureFormat(format))
83 // except that it supports some formats that are not mappable to VkFormat.
84 // When we are checking combined depth and stencil formats, each aspect is
85 // checked separately, and in some cases we construct PBA with a format that
86 // is not mappable to VkFormat.
87 bool isFloatFormat (tcu::TextureFormat format)
89 return tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
94 VkBufferCopy bufferCopy;
95 VkImageCopy imageCopy;
96 VkBufferImageCopy bufferImageCopy;
97 VkImageBlit imageBlit;
98 VkImageResolve imageResolve;
103 VkImageType imageType;
120 std::vector<CopyRegion> regions;
125 VkSampleCountFlagBits samples;
129 inline deUint32 getArraySize(const ImageParms& parms)
131 return (parms.imageType == VK_IMAGE_TYPE_2D) ? parms.extent.depth : 1u;
134 inline VkExtent3D getExtent3D(const ImageParms& parms)
136 const VkExtent3D extent =
140 (parms.imageType == VK_IMAGE_TYPE_2D) ? 1u : parms.extent.depth
145 const tcu::TextureFormat mapCombinedToDepthTransferFormat (const tcu::TextureFormat& combinedFormat)
147 tcu::TextureFormat format;
148 switch (combinedFormat.type)
150 case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
151 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
153 case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
154 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNSIGNED_INT_24_8_REV);
156 case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
157 format = tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
166 class CopiesAndBlittingTestInstance : public vkt::TestInstance
169 CopiesAndBlittingTestInstance (Context& context,
170 TestParams testParams);
171 virtual tcu::TestStatus iterate (void) = 0;
175 FILL_MODE_GRADIENT = 0,
178 FILL_MODE_MULTISAMPLE,
184 const TestParams m_params;
186 Move<VkCommandPool> m_cmdPool;
187 Move<VkCommandBuffer> m_cmdBuffer;
188 Move<VkFence> m_fence;
189 de::MovePtr<tcu::TextureLevel> m_sourceTextureLevel;
190 de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
191 de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
193 VkCommandBufferBeginInfo m_cmdBufferBeginInfo;
195 void generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth = 1, FillMode = FILL_MODE_GRADIENT);
196 virtual void generateExpectedResult (void);
197 void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
198 void uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms);
199 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
200 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
201 deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
203 return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
206 de::MovePtr<tcu::TextureLevel> readImage (vk::VkImage image,
207 const ImageParms& imageParms);
208 void submitCommandsAndWait (const DeviceInterface& vk,
209 const VkDevice device,
211 const VkCommandBuffer& cmdBuffer);
214 void uploadImageAspect (const tcu::ConstPixelBufferAccess& src,
216 const ImageParms& parms);
217 void readImageAspect (vk::VkImage src,
218 const tcu::PixelBufferAccess& dst,
219 const ImageParms& parms);
222 CopiesAndBlittingTestInstance::CopiesAndBlittingTestInstance (Context& context, TestParams testParams)
223 : vkt::TestInstance (context)
224 , m_params (testParams)
226 const DeviceInterface& vk = context.getDeviceInterface();
227 const VkDevice vkDevice = context.getDevice();
228 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
230 // Create command pool
231 m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
233 // Create command buffer
234 m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
237 m_fence = createFence(vk, vkDevice);
240 void CopiesAndBlittingTestInstance::generateBuffer (tcu::PixelBufferAccess buffer, int width, int height, int depth, FillMode mode)
242 if (mode == FILL_MODE_GRADIENT)
244 tcu::fillWithComponentGradients(buffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
248 const tcu::Vec4 redColor (1.0, 0.0, 0.0, 1.0);
249 const tcu::Vec4 greenColor (0.0, 1.0, 0.0, 1.0);
250 const tcu::Vec4 blueColor (0.0, 0.0, 1.0, 1.0);
251 const tcu::Vec4 whiteColor (1.0, 1.0, 1.0, 1.0);
253 for (int z = 0; z < depth; z++)
255 for (int y = 0; y < height; y++)
257 for (int x = 0; x < width; x++)
261 case FILL_MODE_WHITE:
262 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
264 buffer.setPixDepth(1.0f, x, y, z);
265 if (tcu::hasStencilComponent(buffer.getFormat().order))
266 buffer.setPixStencil(255, x, y, z);
269 buffer.setPixel(whiteColor, x, y, z);
272 if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
274 buffer.setPixDepth(redColor[x % 4], x, y, z);
275 if (tcu::hasStencilComponent(buffer.getFormat().order))
276 buffer.setPixStencil(255 * (int)redColor[y % 4], x, y, z);
279 buffer.setPixel(redColor, x, y, z);
281 case FILL_MODE_MULTISAMPLE:
282 buffer.setPixel((x == y) ? tcu::Vec4(0.0, 0.5, 0.5, 1.0) : ((x > y) ? greenColor : blueColor), x, y, z);
292 void CopiesAndBlittingTestInstance::uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc)
294 const DeviceInterface& vk = m_context.getDeviceInterface();
295 const VkDevice vkDevice = m_context.getDevice();
296 const deUint32 bufferSize = calculateSize(bufferAccess);
299 deMemcpy(bufferAlloc.getHostPtr(), bufferAccess.getDataPtr(), bufferSize);
300 flushMappedMemoryRange(vk, vkDevice, bufferAlloc.getMemory(), bufferAlloc.getOffset(), bufferSize);
303 void CopiesAndBlittingTestInstance::uploadImageAspect (const tcu::ConstPixelBufferAccess& imageAccess, const VkImage& image, const ImageParms& parms)
305 const DeviceInterface& vk = m_context.getDeviceInterface();
306 const VkDevice vkDevice = m_context.getDevice();
307 const VkQueue queue = m_context.getUniversalQueue();
308 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
309 Allocator& memAlloc = m_context.getDefaultAllocator();
310 Move<VkBuffer> buffer;
311 const deUint32 bufferSize = calculateSize(imageAccess);
312 de::MovePtr<Allocation> bufferAlloc;
313 const deUint32 arraySize = getArraySize(parms);
314 const VkExtent3D imageExtent = getExtent3D(parms);
316 // Create source buffer
318 const VkBufferCreateInfo bufferParams =
320 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
321 DE_NULL, // const void* pNext;
322 0u, // VkBufferCreateFlags flags;
323 bufferSize, // VkDeviceSize size;
324 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
325 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
326 1u, // deUint32 queueFamilyIndexCount;
327 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
330 buffer = createBuffer(vk, vkDevice, &bufferParams);
331 bufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *buffer), MemoryRequirement::HostVisible);
332 VK_CHECK(vk.bindBufferMemory(vkDevice, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
335 // Barriers for copying buffer to image
336 const VkBufferMemoryBarrier preBufferBarrier =
338 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
339 DE_NULL, // const void* pNext;
340 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
341 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
342 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
343 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
344 *buffer, // VkBuffer buffer;
345 0u, // VkDeviceSize offset;
346 bufferSize // VkDeviceSize size;
349 const VkImageAspectFlags formatAspect = getAspectFlags(mapVkFormat(parms.format));
350 const bool skipPreImageBarrier = formatAspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) &&
351 getAspectFlags(imageAccess.getFormat()) == VK_IMAGE_ASPECT_STENCIL_BIT;
352 const VkImageMemoryBarrier preImageBarrier =
354 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
355 DE_NULL, // const void* pNext;
356 0u, // VkAccessFlags srcAccessMask;
357 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
358 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
359 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
360 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
361 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
362 image, // VkImage image;
363 { // VkImageSubresourceRange subresourceRange;
364 formatAspect, // VkImageAspectFlags aspect;
365 0u, // deUint32 baseMipLevel;
366 1u, // deUint32 mipLevels;
367 0u, // deUint32 baseArraySlice;
368 arraySize, // deUint32 arraySize;
372 const VkImageMemoryBarrier postImageBarrier =
374 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
375 DE_NULL, // const void* pNext;
376 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
377 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
378 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
379 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
380 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
381 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
382 image, // VkImage image;
383 { // VkImageSubresourceRange subresourceRange;
384 formatAspect, // VkImageAspectFlags aspect;
385 0u, // deUint32 baseMipLevel;
386 1u, // deUint32 mipLevels;
387 0u, // deUint32 baseArraySlice;
388 arraySize, // deUint32 arraySize;
392 const VkBufferImageCopy copyRegion =
394 0u, // VkDeviceSize bufferOffset;
395 (deUint32)imageAccess.getWidth(), // deUint32 bufferRowLength;
396 (deUint32)imageAccess.getHeight(), // deUint32 bufferImageHeight;
398 getAspectFlags(imageAccess.getFormat()), // VkImageAspectFlags aspect;
399 0u, // deUint32 mipLevel;
400 0u, // deUint32 baseArrayLayer;
401 arraySize, // deUint32 layerCount;
402 }, // VkImageSubresourceLayers imageSubresource;
403 { 0, 0, 0 }, // VkOffset3D imageOffset;
404 imageExtent // VkExtent3D imageExtent;
408 deMemcpy(bufferAlloc->getHostPtr(), imageAccess.getDataPtr(), bufferSize);
409 flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
411 // Copy buffer to image
412 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
414 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
415 DE_NULL, // const void* pNext;
416 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
417 (const VkCommandBufferInheritanceInfo*)DE_NULL,
420 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
421 vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL,
422 1, &preBufferBarrier, (skipPreImageBarrier ? 0 : 1), (skipPreImageBarrier ? DE_NULL : &preImageBarrier));
423 vk.cmdCopyBufferToImage(*m_cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
424 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);
425 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
427 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
430 void CopiesAndBlittingTestInstance::uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms)
432 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
434 if (tcu::hasDepthComponent(src.getFormat().order))
436 tcu::TextureLevel depthTexture (mapCombinedToDepthTransferFormat(src.getFormat()), src.getWidth(), src.getHeight(), src.getDepth());
437 tcu::copy(depthTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH));
438 uploadImageAspect(depthTexture.getAccess(), dst, parms);
441 if (tcu::hasStencilComponent(src.getFormat().order))
443 tcu::TextureLevel stencilTexture (tcu::getEffectiveDepthStencilTextureFormat(src.getFormat(), tcu::Sampler::MODE_STENCIL), src.getWidth(), src.getHeight(), src.getDepth());
444 tcu::copy(stencilTexture.getAccess(), tcu::getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL));
445 uploadImageAspect(stencilTexture.getAccess(), dst, parms);
449 uploadImageAspect(src, dst, parms);
452 tcu::TestStatus CopiesAndBlittingTestInstance::checkTestResult (tcu::ConstPixelBufferAccess result)
454 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
456 if (isFloatFormat(result.getFormat()))
458 const tcu::Vec4 threshold (0.0f);
459 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
460 return tcu::TestStatus::fail("CopiesAndBlitting test");
464 const tcu::UVec4 threshold (0u);
465 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expected, result, threshold, tcu::COMPARE_LOG_RESULT))
466 return tcu::TestStatus::fail("CopiesAndBlitting test");
469 return tcu::TestStatus::pass("CopiesAndBlitting test");
472 void CopiesAndBlittingTestInstance::generateExpectedResult (void)
474 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
475 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
477 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
478 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
480 for (deUint32 i = 0; i < m_params.regions.size(); i++)
481 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), m_params.regions[i]);
484 class CopiesAndBlittingTestCase : public vkt::TestCase
487 CopiesAndBlittingTestCase (tcu::TestContext& testCtx,
488 const std::string& name,
489 const std::string& description)
490 : vkt::TestCase (testCtx, name, description)
493 virtual TestInstance* createInstance (Context& context) const = 0;
496 void CopiesAndBlittingTestInstance::readImageAspect (vk::VkImage image,
497 const tcu::PixelBufferAccess& dst,
498 const ImageParms& imageParms)
500 const DeviceInterface& vk = m_context.getDeviceInterface();
501 const VkDevice device = m_context.getDevice();
502 const VkQueue queue = m_context.getUniversalQueue();
503 Allocator& allocator = m_context.getDefaultAllocator();
505 Move<VkBuffer> buffer;
506 de::MovePtr<Allocation> bufferAlloc;
507 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
508 const VkDeviceSize pixelDataSize = calculateSize(dst);
509 const VkExtent3D imageExtent = getExtent3D(imageParms);
511 // Create destination buffer
513 const VkBufferCreateInfo bufferParams =
515 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
516 DE_NULL, // const void* pNext;
517 0u, // VkBufferCreateFlags flags;
518 pixelDataSize, // VkDeviceSize size;
519 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
520 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
521 1u, // deUint32 queueFamilyIndexCount;
522 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
525 buffer = createBuffer(vk, device, &bufferParams);
526 bufferAlloc = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffer), MemoryRequirement::HostVisible);
527 VK_CHECK(vk.bindBufferMemory(device, *buffer, bufferAlloc->getMemory(), bufferAlloc->getOffset()));
529 deMemset(bufferAlloc->getHostPtr(), 0, static_cast<size_t>(pixelDataSize));
530 flushMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
533 // Barriers for copying image to buffer
534 const VkImageAspectFlags formatAspect = getAspectFlags(mapVkFormat(imageParms.format));
535 const VkImageMemoryBarrier imageBarrier =
537 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
538 DE_NULL, // const void* pNext;
539 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
540 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
541 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
542 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
543 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
544 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
545 image, // VkImage image;
546 { // VkImageSubresourceRange subresourceRange;
547 formatAspect, // VkImageAspectFlags aspectMask;
548 0u, // deUint32 baseMipLevel;
549 1u, // deUint32 mipLevels;
550 0u, // deUint32 baseArraySlice;
551 getArraySize(imageParms)// deUint32 arraySize;
555 const VkBufferMemoryBarrier bufferBarrier =
557 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
558 DE_NULL, // const void* pNext;
559 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
560 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
561 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
562 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
563 *buffer, // VkBuffer buffer;
564 0u, // VkDeviceSize offset;
565 pixelDataSize // VkDeviceSize size;
568 const VkImageMemoryBarrier postImageBarrier =
570 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
571 DE_NULL, // const void* pNext;
572 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags srcAccessMask;
573 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
574 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout oldLayout;
575 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
576 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
577 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
578 image, // VkImage image;
580 formatAspect, // VkImageAspectFlags aspectMask;
581 0u, // deUint32 baseMipLevel;
582 1u, // deUint32 mipLevels;
583 0u, // deUint32 baseArraySlice;
584 getArraySize(imageParms) // deUint32 arraySize;
585 } // VkImageSubresourceRange subresourceRange;
588 // Copy image to buffer
589 const VkImageAspectFlags aspect = getAspectFlags(dst.getFormat());
590 const VkBufferImageCopy copyRegion =
592 0u, // VkDeviceSize bufferOffset;
593 (deUint32)dst.getWidth(), // deUint32 bufferRowLength;
594 (deUint32)dst.getHeight(), // deUint32 bufferImageHeight;
596 aspect, // VkImageAspectFlags aspect;
597 0u, // deUint32 mipLevel;
598 0u, // deUint32 baseArrayLayer;
599 getArraySize(imageParms), // deUint32 layerCount;
600 }, // VkImageSubresourceLayers imageSubresource;
601 { 0, 0, 0 }, // VkOffset3D imageOffset;
602 imageExtent // VkExtent3D imageExtent;
605 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
607 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
608 DE_NULL, // const void* pNext;
609 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
610 (const VkCommandBufferInheritanceInfo*)DE_NULL,
613 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
614 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);
615 vk.cmdCopyImageToBuffer(*m_cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1u, ©Region);
616 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);
617 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
619 submitCommandsAndWait(vk, device, queue, *m_cmdBuffer);
622 invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), pixelDataSize);
623 tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferAlloc->getHostPtr()));
626 void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
628 const VkSubmitInfo submitInfo =
630 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
631 DE_NULL, // const void* pNext;
632 0u, // deUint32 waitSemaphoreCount;
633 DE_NULL, // const VkSemaphore* pWaitSemaphores;
634 (const VkPipelineStageFlags*)DE_NULL,
635 1u, // deUint32 commandBufferCount;
636 &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
637 0u, // deUint32 signalSemaphoreCount;
638 DE_NULL // const VkSemaphore* pSignalSemaphores;
641 VK_CHECK(vk.resetFences(device, 1, &m_fence.get()));
642 VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
643 VK_CHECK(vk.waitForFences(device, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
646 de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (vk::VkImage image,
647 const ImageParms& parms)
649 const tcu::TextureFormat imageFormat = mapVkFormat(parms.format);
650 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(imageFormat, parms.extent.width, parms.extent.height, parms.extent.depth));
652 if (tcu::isCombinedDepthStencilType(imageFormat.type))
654 if (tcu::hasDepthComponent(imageFormat.order))
656 tcu::TextureLevel depthTexture (mapCombinedToDepthTransferFormat(imageFormat), parms.extent.width, parms.extent.height, parms.extent.depth);
657 readImageAspect(image, depthTexture.getAccess(), parms);
658 tcu::copy(tcu::getEffectiveDepthStencilAccess(resultLevel->getAccess(), tcu::Sampler::MODE_DEPTH), depthTexture.getAccess());
661 if (tcu::hasStencilComponent(imageFormat.order))
663 tcu::TextureLevel stencilTexture (tcu::getEffectiveDepthStencilTextureFormat(imageFormat, tcu::Sampler::MODE_STENCIL), parms.extent.width, parms.extent.height, parms.extent.depth);
664 readImageAspect(image, stencilTexture.getAccess(), parms);
665 tcu::copy(tcu::getEffectiveDepthStencilAccess(resultLevel->getAccess(), tcu::Sampler::MODE_STENCIL), stencilTexture.getAccess());
669 readImageAspect(image, resultLevel->getAccess(), parms);
674 // Copy from image to image.
676 class CopyImageToImage : public CopiesAndBlittingTestInstance
679 CopyImageToImage (Context& context,
681 virtual tcu::TestStatus iterate (void);
684 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
687 Move<VkImage> m_source;
688 de::MovePtr<Allocation> m_sourceImageAlloc;
689 Move<VkImage> m_destination;
690 de::MovePtr<Allocation> m_destinationImageAlloc;
692 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
695 CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
696 : CopiesAndBlittingTestInstance(context, params)
698 const DeviceInterface& vk = context.getDeviceInterface();
699 const VkDevice vkDevice = context.getDevice();
700 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
701 Allocator& memAlloc = context.getDefaultAllocator();
703 if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
704 (m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
706 if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance1") == context.getDeviceExtensions().end())
707 TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
710 VkImageFormatProperties properties;
711 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
712 m_params.src.image.format,
713 m_params.src.image.imageType,
714 VK_IMAGE_TILING_OPTIMAL,
715 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
717 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
718 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
719 m_params.dst.image.format,
720 m_params.dst.image.imageType,
721 VK_IMAGE_TILING_OPTIMAL,
722 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
724 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
726 TCU_THROW(NotSupportedError, "Format not supported");
729 // Create source image
731 const VkImageCreateInfo sourceImageParams =
733 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
734 DE_NULL, // const void* pNext;
735 0u, // VkImageCreateFlags flags;
736 m_params.src.image.imageType, // VkImageType imageType;
737 m_params.src.image.format, // VkFormat format;
738 getExtent3D(m_params.src.image), // VkExtent3D extent;
739 1u, // deUint32 mipLevels;
740 getArraySize(m_params.src.image), // deUint32 arraySize;
741 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
742 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
743 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
744 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
745 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
746 1u, // deUint32 queueFamilyCount;
747 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
748 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
751 m_source = createImage(vk, vkDevice, &sourceImageParams);
752 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
753 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
756 // Create destination image
758 const VkImageCreateInfo destinationImageParams =
760 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
761 DE_NULL, // const void* pNext;
762 0u, // VkImageCreateFlags flags;
763 m_params.dst.image.imageType, // VkImageType imageType;
764 m_params.dst.image.format, // VkFormat format;
765 getExtent3D(m_params.dst.image), // VkExtent3D extent;
766 1u, // deUint32 mipLevels;
767 getArraySize(m_params.dst.image), // deUint32 arraySize;
768 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
769 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
770 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
771 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
772 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
773 1u, // deUint32 queueFamilyCount;
774 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
775 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
778 m_destination = createImage(vk, vkDevice, &destinationImageParams);
779 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
780 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
784 tcu::TestStatus CopyImageToImage::iterate (void)
786 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
787 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
788 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
789 (int)m_params.src.image.extent.width,
790 (int)m_params.src.image.extent.height,
791 (int)m_params.src.image.extent.depth));
792 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);
793 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
794 (int)m_params.dst.image.extent.width,
795 (int)m_params.dst.image.extent.height,
796 (int)m_params.dst.image.extent.depth));
797 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);
798 generateExpectedResult();
800 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
801 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
803 const DeviceInterface& vk = m_context.getDeviceInterface();
804 const VkDevice vkDevice = m_context.getDevice();
805 const VkQueue queue = m_context.getUniversalQueue();
807 std::vector<VkImageCopy> imageCopies;
808 for (deUint32 i = 0; i < m_params.regions.size(); i++)
809 imageCopies.push_back(m_params.regions[i].imageCopy);
811 const VkImageMemoryBarrier imageBarriers[] =
815 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
816 DE_NULL, // const void* pNext;
817 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
818 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
819 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
820 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
821 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
822 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
823 m_source.get(), // VkImage image;
824 { // VkImageSubresourceRange subresourceRange;
825 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
826 0u, // deUint32 baseMipLevel;
827 1u, // deUint32 mipLevels;
828 0u, // deUint32 baseArraySlice;
829 getArraySize(m_params.src.image)// deUint32 arraySize;
834 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
835 DE_NULL, // const void* pNext;
836 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
837 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
838 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
839 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
840 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
841 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
842 m_destination.get(), // VkImage image;
843 { // VkImageSubresourceRange subresourceRange;
844 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
845 0u, // deUint32 baseMipLevel;
846 1u, // deUint32 mipLevels;
847 0u, // deUint32 baseArraySlice;
848 getArraySize(m_params.dst.image)// deUint32 arraySize;
853 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
855 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
856 DE_NULL, // const void* pNext;
857 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
858 (const VkCommandBufferInheritanceInfo*)DE_NULL,
861 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
862 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);
863 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());
864 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
866 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
868 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
870 return checkTestResult(resultTextureLevel->getAccess());
873 tcu::TestStatus CopyImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
875 const tcu::Vec4 fThreshold (0.0f);
876 const tcu::UVec4 uThreshold (0u);
878 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
880 if (tcu::hasDepthComponent(result.getFormat().order))
882 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_DEPTH;
883 const tcu::ConstPixelBufferAccess depthResult = tcu::getEffectiveDepthStencilAccess(result, mode);
884 const tcu::ConstPixelBufferAccess expectedResult = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
886 if (isFloatFormat(result.getFormat()))
888 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, depthResult, fThreshold, tcu::COMPARE_LOG_RESULT))
889 return tcu::TestStatus::fail("CopiesAndBlitting test");
893 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, depthResult, uThreshold, tcu::COMPARE_LOG_RESULT))
894 return tcu::TestStatus::fail("CopiesAndBlitting test");
898 if (tcu::hasStencilComponent(result.getFormat().order))
900 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_STENCIL;
901 const tcu::ConstPixelBufferAccess stencilResult = tcu::getEffectiveDepthStencilAccess(result, mode);
902 const tcu::ConstPixelBufferAccess expectedResult = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
904 if (isFloatFormat(result.getFormat()))
906 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, stencilResult, fThreshold, tcu::COMPARE_LOG_RESULT))
907 return tcu::TestStatus::fail("CopiesAndBlitting test");
911 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedResult, stencilResult, uThreshold, tcu::COMPARE_LOG_RESULT))
912 return tcu::TestStatus::fail("CopiesAndBlitting test");
918 if (isFloatFormat(result.getFormat()))
920 if (!tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", m_expectedTextureLevel->getAccess(), result, fThreshold, tcu::COMPARE_LOG_RESULT))
921 return tcu::TestStatus::fail("CopiesAndBlitting test");
925 if (!tcu::intThresholdCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", m_expectedTextureLevel->getAccess(), result, uThreshold, tcu::COMPARE_LOG_RESULT))
926 return tcu::TestStatus::fail("CopiesAndBlitting test");
930 return tcu::TestStatus::pass("CopiesAndBlitting test");
933 void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
935 VkOffset3D srcOffset = region.imageCopy.srcOffset;
936 VkOffset3D dstOffset = region.imageCopy.dstOffset;
937 VkExtent3D extent = region.imageCopy.extent;
939 if (m_params.src.image.imageType == VK_IMAGE_TYPE_3D && m_params.dst.image.imageType == VK_IMAGE_TYPE_2D)
940 dstOffset.z = srcOffset.z;
941 if (m_params.src.image.imageType == VK_IMAGE_TYPE_2D && m_params.dst.image.imageType == VK_IMAGE_TYPE_3D)
943 srcOffset.z = dstOffset.z;
944 extent.depth = std::max(region.imageCopy.extent.depth, region.imageCopy.srcSubresource.layerCount);
948 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
950 DE_ASSERT(src.getFormat() == dst.getFormat());
953 if (tcu::hasDepthComponent(src.getFormat().order))
955 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
956 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_DEPTH);
957 tcu::copy(dstSubRegion, srcSubRegion);
961 if (tcu::hasStencilComponent(src.getFormat().order))
963 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
964 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth), tcu::Sampler::MODE_STENCIL);
965 tcu::copy(dstSubRegion, srcSubRegion);
970 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
971 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
972 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
973 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
975 tcu::copy(dstSubRegion, srcSubRegion);
979 class CopyImageToImageTestCase : public vkt::TestCase
982 CopyImageToImageTestCase (tcu::TestContext& testCtx,
983 const std::string& name,
984 const std::string& description,
985 const TestParams params)
986 : vkt::TestCase (testCtx, name, description)
990 virtual TestInstance* createInstance (Context& context) const
992 return new CopyImageToImage(context, m_params);
998 // Copy from buffer to buffer.
1000 class CopyBufferToBuffer : public CopiesAndBlittingTestInstance
1003 CopyBufferToBuffer (Context& context, TestParams params);
1004 virtual tcu::TestStatus iterate (void);
1006 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
1007 Move<VkBuffer> m_source;
1008 de::MovePtr<Allocation> m_sourceBufferAlloc;
1009 Move<VkBuffer> m_destination;
1010 de::MovePtr<Allocation> m_destinationBufferAlloc;
1013 CopyBufferToBuffer::CopyBufferToBuffer (Context& context, TestParams params)
1014 : CopiesAndBlittingTestInstance (context, params)
1016 const DeviceInterface& vk = context.getDeviceInterface();
1017 const VkDevice vkDevice = context.getDevice();
1018 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1019 Allocator& memAlloc = context.getDefaultAllocator();
1021 // Create source buffer
1023 const VkBufferCreateInfo sourceBufferParams =
1025 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1026 DE_NULL, // const void* pNext;
1027 0u, // VkBufferCreateFlags flags;
1028 m_params.src.buffer.size, // VkDeviceSize size;
1029 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1030 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1031 1u, // deUint32 queueFamilyIndexCount;
1032 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1035 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1036 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1037 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1040 // Create destination buffer
1042 const VkBufferCreateInfo destinationBufferParams =
1044 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1045 DE_NULL, // const void* pNext;
1046 0u, // VkBufferCreateFlags flags;
1047 m_params.dst.buffer.size, // VkDeviceSize size;
1048 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1049 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1050 1u, // deUint32 queueFamilyIndexCount;
1051 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1054 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1055 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1056 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1060 tcu::TestStatus CopyBufferToBuffer::iterate (void)
1062 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
1063 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
1064 generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
1066 const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
1067 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1068 generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
1070 generateExpectedResult();
1072 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1073 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1075 const DeviceInterface& vk = m_context.getDeviceInterface();
1076 const VkDevice vkDevice = m_context.getDevice();
1077 const VkQueue queue = m_context.getUniversalQueue();
1079 const VkBufferMemoryBarrier srcBufferBarrier =
1081 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1082 DE_NULL, // const void* pNext;
1083 VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
1084 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1085 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1086 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1087 *m_source, // VkBuffer buffer;
1088 0u, // VkDeviceSize offset;
1089 m_params.src.buffer.size // VkDeviceSize size;
1092 const VkBufferMemoryBarrier dstBufferBarrier =
1094 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1095 DE_NULL, // const void* pNext;
1096 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1097 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1098 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1099 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1100 *m_destination, // VkBuffer buffer;
1101 0u, // VkDeviceSize offset;
1102 m_params.dst.buffer.size // VkDeviceSize size;
1105 std::vector<VkBufferCopy> bufferCopies;
1106 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1107 bufferCopies.push_back(m_params.regions[i].bufferCopy);
1109 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1111 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1112 DE_NULL, // const void* pNext;
1113 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1114 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1117 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1118 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);
1119 vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), &bufferCopies[0]);
1120 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);
1121 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1122 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1127 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
1128 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
1129 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1131 return checkTestResult(resultLevel->getAccess());
1134 void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1136 deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
1137 (deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
1138 (size_t)region.bufferCopy.size);
1141 class BufferToBufferTestCase : public vkt::TestCase
1144 BufferToBufferTestCase (tcu::TestContext& testCtx,
1145 const std::string& name,
1146 const std::string& description,
1147 const TestParams params)
1148 : vkt::TestCase (testCtx, name, description)
1152 virtual TestInstance* createInstance (Context& context) const
1154 return new CopyBufferToBuffer(context, m_params);
1157 TestParams m_params;
1160 // Copy from image to buffer.
1162 class CopyImageToBuffer : public CopiesAndBlittingTestInstance
1165 CopyImageToBuffer (Context& context,
1166 TestParams testParams);
1167 virtual tcu::TestStatus iterate (void);
1169 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1171 tcu::TextureFormat m_textureFormat;
1172 VkDeviceSize m_bufferSize;
1174 Move<VkImage> m_source;
1175 de::MovePtr<Allocation> m_sourceImageAlloc;
1176 Move<VkBuffer> m_destination;
1177 de::MovePtr<Allocation> m_destinationBufferAlloc;
1180 CopyImageToBuffer::CopyImageToBuffer (Context& context, TestParams testParams)
1181 : CopiesAndBlittingTestInstance(context, testParams)
1182 , m_textureFormat(mapVkFormat(testParams.src.image.format))
1183 , m_bufferSize(m_params.dst.buffer.size * tcu::getPixelSize(m_textureFormat))
1185 const DeviceInterface& vk = context.getDeviceInterface();
1186 const VkDevice vkDevice = context.getDevice();
1187 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1188 Allocator& memAlloc = context.getDefaultAllocator();
1190 // Create source image
1192 const VkImageCreateInfo sourceImageParams =
1194 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1195 DE_NULL, // const void* pNext;
1196 0u, // VkImageCreateFlags flags;
1197 m_params.src.image.imageType, // VkImageType imageType;
1198 m_params.src.image.format, // VkFormat format;
1199 getExtent3D(m_params.src.image), // VkExtent3D extent;
1200 1u, // deUint32 mipLevels;
1201 getArraySize(m_params.src.image), // deUint32 arraySize;
1202 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1203 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1204 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1205 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1206 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1207 1u, // deUint32 queueFamilyCount;
1208 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1209 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1212 m_source = createImage(vk, vkDevice, &sourceImageParams);
1213 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1214 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1217 // Create destination buffer
1219 const VkBufferCreateInfo destinationBufferParams =
1221 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1222 DE_NULL, // const void* pNext;
1223 0u, // VkBufferCreateFlags flags;
1224 m_bufferSize, // VkDeviceSize size;
1225 VK_BUFFER_USAGE_TRANSFER_DST_BIT, // VkBufferUsageFlags usage;
1226 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1227 1u, // deUint32 queueFamilyIndexCount;
1228 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1231 m_destination = createBuffer(vk, vkDevice, &destinationBufferParams);
1232 m_destinationBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::HostVisible);
1233 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_destination, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset()));
1237 tcu::TestStatus CopyImageToBuffer::iterate (void)
1239 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1240 m_params.src.image.extent.width,
1241 m_params.src.image.extent.height,
1242 m_params.src.image.extent.depth));
1243 generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
1244 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1245 generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
1247 generateExpectedResult();
1249 uploadImage(m_sourceTextureLevel->getAccess(), *m_source, m_params.src.image);
1250 uploadBuffer(m_destinationTextureLevel->getAccess(), *m_destinationBufferAlloc);
1252 const DeviceInterface& vk = m_context.getDeviceInterface();
1253 const VkDevice vkDevice = m_context.getDevice();
1254 const VkQueue queue = m_context.getUniversalQueue();
1256 // Barriers for copying image to buffer
1257 const VkImageMemoryBarrier imageBarrier =
1259 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1260 DE_NULL, // const void* pNext;
1261 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1262 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1263 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1264 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1265 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1266 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1267 *m_source, // VkImage image;
1268 { // VkImageSubresourceRange subresourceRange;
1269 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1270 0u, // deUint32 baseMipLevel;
1271 1u, // deUint32 mipLevels;
1272 0u, // deUint32 baseArraySlice;
1273 1u // deUint32 arraySize;
1277 const VkBufferMemoryBarrier bufferBarrier =
1279 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1280 DE_NULL, // const void* pNext;
1281 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1282 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1283 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1284 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1285 *m_destination, // VkBuffer buffer;
1286 0u, // VkDeviceSize offset;
1287 m_bufferSize // VkDeviceSize size;
1290 // Copy from image to buffer
1291 std::vector<VkBufferImageCopy> bufferImageCopies;
1292 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1293 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1295 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1297 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1298 DE_NULL, // const void* pNext;
1299 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1300 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1303 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1304 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);
1305 vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), &bufferImageCopies[0]);
1306 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);
1307 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1309 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1312 de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_textureFormat, (int)m_params.dst.buffer.size, 1));
1313 invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_bufferSize);
1314 tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
1316 return checkTestResult(resultLevel->getAccess());
1319 class CopyImageToBufferTestCase : public vkt::TestCase
1322 CopyImageToBufferTestCase (tcu::TestContext& testCtx,
1323 const std::string& name,
1324 const std::string& description,
1325 const TestParams params)
1326 : vkt::TestCase (testCtx, name, description)
1330 virtual TestInstance* createInstance (Context& context) const
1332 return new CopyImageToBuffer(context, m_params);
1335 TestParams m_params;
1338 void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1340 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1342 rowLength = region.bufferImageCopy.imageExtent.width;
1344 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1346 imageHeight = region.bufferImageCopy.imageExtent.height;
1348 const int texelSize = src.getFormat().getPixelSize();
1349 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1350 const VkOffset3D srcOffset = region.bufferImageCopy.imageOffset;
1351 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1353 for (deUint32 z = 0; z < extent.depth; z++)
1355 for (deUint32 y = 0; y < extent.height; y++)
1357 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1358 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
1359 region.bufferImageCopy.imageExtent.width, 1, 1);
1360 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1361 tcu::copy(dstSubRegion, srcSubRegion);
1366 // Copy from buffer to image.
1368 class CopyBufferToImage : public CopiesAndBlittingTestInstance
1371 CopyBufferToImage (Context& context,
1372 TestParams testParams);
1373 virtual tcu::TestStatus iterate (void);
1375 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1377 tcu::TextureFormat m_textureFormat;
1378 VkDeviceSize m_bufferSize;
1380 Move<VkBuffer> m_source;
1381 de::MovePtr<Allocation> m_sourceBufferAlloc;
1382 Move<VkImage> m_destination;
1383 de::MovePtr<Allocation> m_destinationImageAlloc;
1386 CopyBufferToImage::CopyBufferToImage (Context& context, TestParams testParams)
1387 : CopiesAndBlittingTestInstance(context, testParams)
1388 , m_textureFormat(mapVkFormat(testParams.dst.image.format))
1389 , m_bufferSize(m_params.src.buffer.size * tcu::getPixelSize(m_textureFormat))
1391 const DeviceInterface& vk = context.getDeviceInterface();
1392 const VkDevice vkDevice = context.getDevice();
1393 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1394 Allocator& memAlloc = context.getDefaultAllocator();
1396 // Create source buffer
1398 const VkBufferCreateInfo sourceBufferParams =
1400 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
1401 DE_NULL, // const void* pNext;
1402 0u, // VkBufferCreateFlags flags;
1403 m_bufferSize, // VkDeviceSize size;
1404 VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage;
1405 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1406 1u, // deUint32 queueFamilyIndexCount;
1407 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1410 m_source = createBuffer(vk, vkDevice, &sourceBufferParams);
1411 m_sourceBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::HostVisible);
1412 VK_CHECK(vk.bindBufferMemory(vkDevice, *m_source, m_sourceBufferAlloc->getMemory(), m_sourceBufferAlloc->getOffset()));
1415 // Create destination image
1417 const VkImageCreateInfo destinationImageParams =
1419 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1420 DE_NULL, // const void* pNext;
1421 0u, // VkImageCreateFlags flags;
1422 m_params.dst.image.imageType, // VkImageType imageType;
1423 m_params.dst.image.format, // VkFormat format;
1424 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1425 1u, // deUint32 mipLevels;
1426 getArraySize(m_params.dst.image), // deUint32 arraySize;
1427 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1428 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1429 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1430 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1431 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1432 1u, // deUint32 queueFamilyCount;
1433 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1434 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1437 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1438 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1439 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1443 tcu::TestStatus CopyBufferToImage::iterate (void)
1445 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
1446 generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1);
1447 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
1448 m_params.dst.image.extent.width,
1449 m_params.dst.image.extent.height,
1450 m_params.dst.image.extent.depth));
1452 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
1454 generateExpectedResult();
1456 uploadBuffer(m_sourceTextureLevel->getAccess(), *m_sourceBufferAlloc);
1457 uploadImage(m_destinationTextureLevel->getAccess(), *m_destination, m_params.dst.image);
1459 const DeviceInterface& vk = m_context.getDeviceInterface();
1460 const VkDevice vkDevice = m_context.getDevice();
1461 const VkQueue queue = m_context.getUniversalQueue();
1463 const VkImageMemoryBarrier imageBarrier =
1465 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1466 DE_NULL, // const void* pNext;
1467 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1468 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1469 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1470 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1471 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1472 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1473 *m_destination, // VkImage image;
1474 { // VkImageSubresourceRange subresourceRange;
1475 getAspectFlags(m_textureFormat), // VkImageAspectFlags aspectMask;
1476 0u, // deUint32 baseMipLevel;
1477 1u, // deUint32 mipLevels;
1478 0u, // deUint32 baseArraySlice;
1479 1u // deUint32 arraySize;
1483 // Copy from buffer to image
1484 std::vector<VkBufferImageCopy> bufferImageCopies;
1485 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1486 bufferImageCopies.push_back(m_params.regions[i].bufferImageCopy);
1488 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1490 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1491 DE_NULL, // const void* pNext;
1492 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1493 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1496 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1497 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);
1498 vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies.data());
1499 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1501 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
1503 de::MovePtr<tcu::TextureLevel> resultLevel = readImage(*m_destination, m_params.dst.image);
1505 return checkTestResult(resultLevel->getAccess());
1508 class CopyBufferToImageTestCase : public vkt::TestCase
1511 CopyBufferToImageTestCase (tcu::TestContext& testCtx,
1512 const std::string& name,
1513 const std::string& description,
1514 const TestParams params)
1515 : vkt::TestCase (testCtx, name, description)
1519 virtual ~CopyBufferToImageTestCase (void) {}
1521 virtual TestInstance* createInstance (Context& context) const
1523 return new CopyBufferToImage(context, m_params);
1526 TestParams m_params;
1529 void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
1531 deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
1533 rowLength = region.bufferImageCopy.imageExtent.width;
1535 deUint32 imageHeight = region.bufferImageCopy.bufferImageHeight;
1537 imageHeight = region.bufferImageCopy.imageExtent.height;
1539 const int texelSize = dst.getFormat().getPixelSize();
1540 const VkExtent3D extent = region.bufferImageCopy.imageExtent;
1541 const VkOffset3D dstOffset = region.bufferImageCopy.imageOffset;
1542 const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
1544 for (deUint32 z = 0; z < extent.depth; z++)
1546 for (deUint32 y = 0; y < extent.height; y++)
1548 int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
1549 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
1550 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y + y, dstOffset.z + z,
1551 region.bufferImageCopy.imageExtent.width, 1, 1);
1552 tcu::copy(dstSubRegion, srcSubRegion);
1557 // Copy from image to image with scaling.
1559 class BlittingImages : public CopiesAndBlittingTestInstance
1562 BlittingImages (Context& context,
1564 virtual tcu::TestStatus iterate (void);
1566 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
1567 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
1568 virtual void generateExpectedResult (void);
1570 bool checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess& result,
1571 const tcu::ConstPixelBufferAccess& clampedReference,
1572 const tcu::ConstPixelBufferAccess& unclampedReference,
1573 VkImageAspectFlagBits aspect);
1574 Move<VkImage> m_source;
1575 de::MovePtr<Allocation> m_sourceImageAlloc;
1576 Move<VkImage> m_destination;
1577 de::MovePtr<Allocation> m_destinationImageAlloc;
1579 de::MovePtr<tcu::TextureLevel> m_unclampedExpectedTextureLevel;
1582 BlittingImages::BlittingImages (Context& context, TestParams params)
1583 : CopiesAndBlittingTestInstance(context, params)
1585 const DeviceInterface& vk = context.getDeviceInterface();
1586 const VkDevice vkDevice = context.getDevice();
1587 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
1588 Allocator& memAlloc = context.getDefaultAllocator();
1590 VkImageFormatProperties properties;
1591 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1592 m_params.src.image.format,
1594 VK_IMAGE_TILING_OPTIMAL,
1595 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1597 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
1598 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
1599 m_params.dst.image.format,
1601 VK_IMAGE_TILING_OPTIMAL,
1602 VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1604 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
1606 TCU_THROW(NotSupportedError, "Format not supported");
1609 VkFormatProperties srcFormatProperties;
1610 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.src.image.format, &srcFormatProperties);
1611 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT))
1613 TCU_THROW(NotSupportedError, "Format feature blit source not supported");
1616 VkFormatProperties dstFormatProperties;
1617 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), m_params.dst.image.format, &dstFormatProperties);
1618 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT))
1620 TCU_THROW(NotSupportedError, "Format feature blit destination not supported");
1623 if (m_params.filter == VK_FILTER_LINEAR)
1625 if (!(srcFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1626 TCU_THROW(NotSupportedError, "Source format feature sampled image filter linear not supported");
1627 if (!(dstFormatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
1628 TCU_THROW(NotSupportedError, "Destination format feature sampled image filter linear not supported");
1631 // Create source image
1633 const VkImageCreateInfo sourceImageParams =
1635 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1636 DE_NULL, // const void* pNext;
1637 0u, // VkImageCreateFlags flags;
1638 m_params.src.image.imageType, // VkImageType imageType;
1639 m_params.src.image.format, // VkFormat format;
1640 getExtent3D(m_params.src.image), // VkExtent3D extent;
1641 1u, // deUint32 mipLevels;
1642 getArraySize(m_params.src.image), // deUint32 arraySize;
1643 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1644 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1645 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1646 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1647 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1648 1u, // deUint32 queueFamilyCount;
1649 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1650 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1653 m_source = createImage(vk, vkDevice, &sourceImageParams);
1654 m_sourceImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_source), MemoryRequirement::Any);
1655 VK_CHECK(vk.bindImageMemory(vkDevice, *m_source, m_sourceImageAlloc->getMemory(), m_sourceImageAlloc->getOffset()));
1658 // Create destination image
1660 const VkImageCreateInfo destinationImageParams =
1662 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1663 DE_NULL, // const void* pNext;
1664 0u, // VkImageCreateFlags flags;
1665 m_params.dst.image.imageType, // VkImageType imageType;
1666 m_params.dst.image.format, // VkFormat format;
1667 getExtent3D(m_params.dst.image), // VkExtent3D extent;
1668 1u, // deUint32 mipLevels;
1669 getArraySize(m_params.dst.image), // deUint32 arraySize;
1670 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
1671 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
1672 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
1673 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
1674 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1675 1u, // deUint32 queueFamilyCount;
1676 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
1677 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
1680 m_destination = createImage(vk, vkDevice, &destinationImageParams);
1681 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
1682 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
1686 tcu::TestStatus BlittingImages::iterate (void)
1688 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
1689 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
1690 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
1691 m_params.src.image.extent.width,
1692 m_params.src.image.extent.height,
1693 m_params.src.image.extent.depth));
1694 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);
1695 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
1696 (int)m_params.dst.image.extent.width,
1697 (int)m_params.dst.image.extent.height,
1698 (int)m_params.dst.image.extent.depth));
1699 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);
1700 generateExpectedResult();
1702 uploadImage(m_sourceTextureLevel->getAccess(), m_source.get(), m_params.src.image);
1703 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
1705 const DeviceInterface& vk = m_context.getDeviceInterface();
1706 const VkDevice vkDevice = m_context.getDevice();
1707 const VkQueue queue = m_context.getUniversalQueue();
1709 std::vector<VkImageBlit> regions;
1710 for (deUint32 i = 0; i < m_params.regions.size(); i++)
1711 regions.push_back(m_params.regions[i].imageBlit);
1713 // Barriers for copying image to buffer
1714 const VkImageMemoryBarrier srcImageBarrier =
1716 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1717 DE_NULL, // const void* pNext;
1718 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1719 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
1720 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1721 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
1722 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1723 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1724 m_source.get(), // VkImage image;
1725 { // VkImageSubresourceRange subresourceRange;
1726 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
1727 0u, // deUint32 baseMipLevel;
1728 1u, // deUint32 mipLevels;
1729 0u, // deUint32 baseArraySlice;
1730 1u // deUint32 arraySize;
1734 const VkImageMemoryBarrier dstImageBarrier =
1736 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
1737 DE_NULL, // const void* pNext;
1738 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1739 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1740 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
1741 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
1742 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1743 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
1744 m_destination.get(), // VkImage image;
1745 { // VkImageSubresourceRange subresourceRange;
1746 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
1747 0u, // deUint32 baseMipLevel;
1748 1u, // deUint32 mipLevels;
1749 0u, // deUint32 baseArraySlice;
1750 1u // deUint32 arraySize;
1754 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1756 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
1757 DE_NULL, // const void* pNext;
1758 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
1759 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1762 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1763 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);
1764 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);
1765 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);
1766 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1767 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
1769 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
1771 return checkTestResult(resultTextureLevel->getAccess());
1774 static float calculateFloatConversionError (int srcBits)
1778 const int clampedBits = de::clamp<int>(srcBits, 0, 32);
1779 const float srcMaxValue = de::max((float)(1ULL<<clampedBits) - 1.0f, 1.0f);
1780 const float error = 1.0f / srcMaxValue;
1782 return de::clamp<float>(error, 0.0f, 1.0f);
1788 tcu::Vec4 getFormatThreshold (const tcu::TextureFormat& format)
1790 tcu::Vec4 threshold(0.01f);
1792 switch (format.type)
1794 case tcu::TextureFormat::HALF_FLOAT:
1795 threshold = tcu::Vec4(0.005f);
1798 case tcu::TextureFormat::FLOAT:
1799 case tcu::TextureFormat::FLOAT64:
1800 threshold = tcu::Vec4(0.001f);
1803 case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
1804 threshold = tcu::Vec4(0.02f, 0.02f, 0.0625f, 1.0f);
1807 case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
1808 threshold = tcu::Vec4(0.05f, 0.05f, 0.05f, 1.0f);
1812 const tcu::IVec4 bits = tcu::getTextureFormatMantissaBitDepth(format);
1813 threshold = tcu::Vec4(calculateFloatConversionError(bits.x()),
1814 calculateFloatConversionError(bits.y()),
1815 calculateFloatConversionError(bits.z()),
1816 calculateFloatConversionError(bits.w()));
1819 // Return value matching the channel order specified by the format
1820 if (format.order == tcu::TextureFormat::BGR || format.order == tcu::TextureFormat::BGRA)
1821 return threshold.swizzle(2, 1, 0, 3);
1826 tcu::TextureFormat getFormatAspect (VkFormat format, VkImageAspectFlagBits aspect)
1828 const tcu::TextureFormat baseFormat = mapVkFormat(format);
1830 if (isCombinedDepthStencilType(baseFormat.type))
1832 if (aspect == VK_IMAGE_ASPECT_DEPTH_BIT)
1833 return getEffectiveDepthStencilTextureFormat(baseFormat, tcu::Sampler::MODE_DEPTH);
1834 else if (aspect == VK_IMAGE_ASPECT_STENCIL_BIT)
1835 return getEffectiveDepthStencilTextureFormat(baseFormat, tcu::Sampler::MODE_STENCIL);
1837 DE_FATAL("Invalid aspect");
1843 bool BlittingImages::checkClampedAndUnclampedResult (const tcu::ConstPixelBufferAccess& result,
1844 const tcu::ConstPixelBufferAccess& clampedExpected,
1845 const tcu::ConstPixelBufferAccess& unclampedExpected,
1846 VkImageAspectFlagBits aspect)
1848 tcu::TestLog& log (m_context.getTestContext().getLog());
1849 const bool isLinear = m_params.filter == VK_FILTER_LINEAR;
1850 const tcu::TextureFormat srcFormat = getFormatAspect(m_params.src.image.format, aspect);
1851 const tcu::TextureFormat dstFormat = result.getFormat();
1854 DE_ASSERT(dstFormat == getFormatAspect(m_params.dst.image.format, aspect));
1857 log << tcu::TestLog::Section("ClampedSourceImage", "Region with clamped edges on source image.");
1859 if (isFloatFormat(dstFormat))
1861 const bool srcIsSRGB = tcu::isSRGB(srcFormat);
1862 const tcu::Vec4 srcMaxDiff = getFormatThreshold(srcFormat) * tcu::Vec4(srcIsSRGB ? 2.0f : 1.0f);
1863 const tcu::Vec4 dstMaxDiff = getFormatThreshold(dstFormat);
1864 const tcu::Vec4 threshold = tcu::max(srcMaxDiff, dstMaxDiff);
1866 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1869 log << tcu::TestLog::EndSection;
1871 if (!isOk && isLinear)
1873 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1874 isOk = tcu::floatThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1875 log << tcu::TestLog::EndSection;
1880 tcu::UVec4 threshold;
1881 // Calculate threshold depending on channel width of destination format.
1882 const tcu::IVec4 bitDepth = tcu::getTextureFormatBitDepth(dstFormat);
1883 for (deUint32 i = 0; i < 4; ++i)
1884 threshold[i] = de::max( (0x1 << bitDepth[i]) / 256, 1);
1886 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", clampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1889 log << tcu::TestLog::EndSection;
1891 if (!isOk && isLinear)
1893 log << tcu::TestLog::Section("NonClampedSourceImage", "Region with non-clamped edges on source image.");
1894 isOk = tcu::intThresholdCompare(log, "Compare", "Result comparsion", unclampedExpected, result, threshold, tcu::COMPARE_LOG_RESULT);
1895 log << tcu::TestLog::EndSection;
1901 tcu::TestStatus BlittingImages::checkTestResult (tcu::ConstPixelBufferAccess result)
1903 DE_ASSERT(m_params.filter == VK_FILTER_NEAREST || m_params.filter == VK_FILTER_LINEAR);
1905 if (tcu::isCombinedDepthStencilType(result.getFormat().type))
1907 if (tcu::hasDepthComponent(result.getFormat().order))
1909 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_DEPTH;
1910 const tcu::ConstPixelBufferAccess depthResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1911 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1912 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1914 if (!checkClampedAndUnclampedResult(depthResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_DEPTH_BIT))
1916 return tcu::TestStatus::fail("CopiesAndBlitting test");
1920 if (tcu::hasStencilComponent(result.getFormat().order))
1922 const tcu::Sampler::DepthStencilMode mode = tcu::Sampler::MODE_STENCIL;
1923 const tcu::ConstPixelBufferAccess stencilResult = tcu::getEffectiveDepthStencilAccess(result, mode);
1924 const tcu::ConstPixelBufferAccess clampedExpected = tcu::getEffectiveDepthStencilAccess(m_expectedTextureLevel->getAccess(), mode);
1925 const tcu::ConstPixelBufferAccess unclampedExpected = m_params.filter == VK_FILTER_LINEAR ? tcu::getEffectiveDepthStencilAccess(m_unclampedExpectedTextureLevel->getAccess(), mode) : tcu::ConstPixelBufferAccess();
1927 if (!checkClampedAndUnclampedResult(stencilResult, clampedExpected, unclampedExpected, VK_IMAGE_ASPECT_STENCIL_BIT))
1929 return tcu::TestStatus::fail("CopiesAndBlitting test");
1935 if (!checkClampedAndUnclampedResult(result, m_expectedTextureLevel->getAccess(), m_params.filter == VK_FILTER_LINEAR ? m_unclampedExpectedTextureLevel->getAccess() : tcu::ConstPixelBufferAccess(), VK_IMAGE_ASPECT_COLOR_BIT))
1937 return tcu::TestStatus::fail("CopiesAndBlitting test");
1941 return tcu::TestStatus::pass("CopiesAndBlitting test");
1944 tcu::Vec4 linearToSRGBIfNeeded (const tcu::TextureFormat& format, const tcu::Vec4& color)
1946 return isSRGB(format) ? linearToSRGB(color) : color;
1949 void scaleFromWholeSrcBuffer (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const VkOffset3D regionOffset, const VkOffset3D regionExtent, tcu::Sampler::FilterMode filter)
1951 DE_ASSERT(filter == tcu::Sampler::LINEAR);
1952 DE_ASSERT(dst.getDepth() == 1 && src.getDepth() == 1);
1954 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1955 filter, filter, 0.0f, false);
1957 float sX = (float)regionExtent.x / (float)dst.getWidth();
1958 float sY = (float)regionExtent.y / (float)dst.getHeight();
1960 for (int y = 0; y < dst.getHeight(); y++)
1961 for (int x = 0; x < dst.getWidth(); x++)
1962 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);
1965 void blit (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src, const tcu::Sampler::FilterMode filter, const MirrorMode mirrorMode)
1967 DE_ASSERT(filter == tcu::Sampler::NEAREST || filter == tcu::Sampler::LINEAR);
1969 tcu::Sampler sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE,
1970 filter, filter, 0.0f, false);
1972 const float sX = (float)src.getWidth() / (float)dst.getWidth();
1973 const float sY = (float)src.getHeight() / (float)dst.getHeight();
1974 const float sZ = (float)src.getDepth() / (float)dst.getDepth();
1976 tcu::Mat2 rotMatrix;
1977 rotMatrix(0,0) = (mirrorMode & MIRROR_MODE_X) ? -1.0f : 1.0f;
1978 rotMatrix(0,1) = 0.0f;
1979 rotMatrix(1,0) = 0.0f;
1980 rotMatrix(1,1) = (mirrorMode & MIRROR_MODE_Y) ? -1.0f : 1.0f;
1982 const int xOffset = (mirrorMode & MIRROR_MODE_X) ? dst.getWidth() - 1 : 0;
1983 const int yOffset = (mirrorMode & MIRROR_MODE_Y) ? dst.getHeight() - 1 : 0;
1985 if (dst.getDepth() == 1 && src.getDepth() == 1)
1987 for (int y = 0; y < dst.getHeight(); ++y)
1988 for (int x = 0; x < dst.getWidth(); ++x)
1990 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
1991 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);
1996 for (int z = 0; z < dst.getDepth(); ++z)
1997 for (int y = 0; y < dst.getHeight(); ++y)
1998 for (int x = 0; x < dst.getWidth(); ++x)
2000 const tcu::Vec2 xy = rotMatrix * tcu::Vec2((float)x,(float)y);
2001 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);
2006 void flipCoordinates (CopyRegion& region, const MirrorMode mirrorMode)
2008 const VkOffset3D dstOffset0 = region.imageBlit.dstOffsets[0];
2009 const VkOffset3D dstOffset1 = region.imageBlit.dstOffsets[1];
2010 const VkOffset3D srcOffset0 = region.imageBlit.srcOffsets[0];
2011 const VkOffset3D srcOffset1 = region.imageBlit.srcOffsets[1];
2013 if (mirrorMode > MIRROR_MODE_NONE && mirrorMode < MIRROR_MODE_LAST)
2016 region.imageBlit.srcOffsets[0].x = std::min(srcOffset0.x, srcOffset1.x);
2017 region.imageBlit.srcOffsets[0].y = std::min(srcOffset0.y, srcOffset1.y);
2019 region.imageBlit.srcOffsets[1].x = std::max(srcOffset0.x, srcOffset1.x);
2020 region.imageBlit.srcOffsets[1].y = std::max(srcOffset0.y, srcOffset1.y);
2023 region.imageBlit.dstOffsets[0].x = std::min(dstOffset0.x, dstOffset1.x);
2024 region.imageBlit.dstOffsets[0].y = std::min(dstOffset0.y, dstOffset1.y);
2026 region.imageBlit.dstOffsets[1].x = std::max(dstOffset0.x, dstOffset1.x);
2027 region.imageBlit.dstOffsets[1].y = std::max(dstOffset0.y, dstOffset1.y);
2031 MirrorMode getMirrorMode(const VkOffset3D x1, const VkOffset3D x2)
2033 if (x1.x >= x2.x && x1.y >= x2.y)
2035 return MIRROR_MODE_XY;
2037 else if (x1.x <= x2.x && x1.y <= x2.y)
2039 return MIRROR_MODE_NONE;
2041 else if (x1.x <= x2.x && x1.y >= x2.y)
2043 return MIRROR_MODE_Y;
2045 else if (x1.x >= x2.x && x1.y <= x2.y)
2047 return MIRROR_MODE_X;
2049 return MIRROR_MODE_LAST;
2052 MirrorMode getMirrorMode(const VkOffset3D s1, const VkOffset3D s2, const VkOffset3D d1, const VkOffset3D d2)
2054 const MirrorMode source = getMirrorMode(s1, s2);
2055 const MirrorMode destination = getMirrorMode(d1, d2);
2057 if (source == destination)
2059 return MIRROR_MODE_NONE;
2061 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_X) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_X) ||
2062 (source == MIRROR_MODE_Y && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_Y && source == MIRROR_MODE_NONE))
2064 return MIRROR_MODE_Y;
2066 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_Y) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_Y) ||
2067 (source == MIRROR_MODE_X && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_X && source == MIRROR_MODE_NONE))
2069 return MIRROR_MODE_X;
2071 else if ((source == MIRROR_MODE_XY && destination == MIRROR_MODE_NONE) || (destination == MIRROR_MODE_XY && source == MIRROR_MODE_NONE))
2073 return MIRROR_MODE_XY;
2075 return MIRROR_MODE_LAST;
2078 void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2080 const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
2081 region.imageBlit.srcOffsets[1],
2082 region.imageBlit.dstOffsets[0],
2083 region.imageBlit.dstOffsets[1]);
2085 flipCoordinates(region, mirrorMode);
2087 const VkOffset3D srcOffset = region.imageBlit.srcOffsets[0];
2088 const VkOffset3D srcExtent =
2090 region.imageBlit.srcOffsets[1].x - srcOffset.x,
2091 region.imageBlit.srcOffsets[1].y - srcOffset.y,
2092 region.imageBlit.srcOffsets[1].z - srcOffset.z
2094 const VkOffset3D dstOffset = region.imageBlit.dstOffsets[0];
2095 const VkOffset3D dstExtent =
2097 region.imageBlit.dstOffsets[1].x - dstOffset.x,
2098 region.imageBlit.dstOffsets[1].y - dstOffset.y,
2099 region.imageBlit.dstOffsets[1].z - dstOffset.z
2101 const tcu::Sampler::FilterMode filter = (m_params.filter == VK_FILTER_LINEAR) ? tcu::Sampler::LINEAR : tcu::Sampler::NEAREST;
2103 if (tcu::isCombinedDepthStencilType(src.getFormat().type))
2105 DE_ASSERT(src.getFormat() == dst.getFormat());
2107 if (tcu::hasDepthComponent(src.getFormat().order))
2109 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_DEPTH);
2110 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
2111 tcu::scale(dstSubRegion, srcSubRegion, filter);
2113 if (filter == tcu::Sampler::LINEAR)
2115 const tcu::ConstPixelBufferAccess depthSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_DEPTH);
2116 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_DEPTH);
2117 scaleFromWholeSrcBuffer(unclampedSubRegion, depthSrc, srcOffset, srcExtent, filter);
2122 if (tcu::hasStencilComponent(src.getFormat().order))
2124 const tcu::ConstPixelBufferAccess srcSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y), tcu::Sampler::MODE_STENCIL);
2125 const tcu::PixelBufferAccess dstSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2126 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2128 if (filter == tcu::Sampler::LINEAR)
2130 const tcu::ConstPixelBufferAccess stencilSrc = getEffectiveDepthStencilAccess(src, tcu::Sampler::MODE_STENCIL);
2131 const tcu::PixelBufferAccess unclampedSubRegion = getEffectiveDepthStencilAccess(tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y), tcu::Sampler::MODE_STENCIL);
2132 scaleFromWholeSrcBuffer(unclampedSubRegion, stencilSrc, srcOffset, srcExtent, filter);
2138 const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y);
2139 const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2140 blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
2142 if (filter == tcu::Sampler::LINEAR)
2144 const tcu::PixelBufferAccess unclampedSubRegion = tcu::getSubregion(m_unclampedExpectedTextureLevel->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
2145 scaleFromWholeSrcBuffer(unclampedSubRegion, src, srcOffset, srcExtent, filter);
2150 void BlittingImages::generateExpectedResult (void)
2152 const tcu::ConstPixelBufferAccess src = m_sourceTextureLevel->getAccess();
2153 const tcu::ConstPixelBufferAccess dst = m_destinationTextureLevel->getAccess();
2155 m_expectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2156 tcu::copy(m_expectedTextureLevel->getAccess(), dst);
2158 if (m_params.filter == VK_FILTER_LINEAR)
2160 m_unclampedExpectedTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dst.getFormat(), dst.getWidth(), dst.getHeight(), dst.getDepth()));
2161 tcu::copy(m_unclampedExpectedTextureLevel->getAccess(), dst);
2164 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2166 CopyRegion region = m_params.regions[i];
2167 copyRegionToTextureLevel(src, m_expectedTextureLevel->getAccess(), region);
2171 class BlittingTestCase : public vkt::TestCase
2174 BlittingTestCase (tcu::TestContext& testCtx,
2175 const std::string& name,
2176 const std::string& description,
2177 const TestParams params)
2178 : vkt::TestCase (testCtx, name, description)
2182 virtual TestInstance* createInstance (Context& context) const
2184 return new BlittingImages(context, m_params);
2187 TestParams m_params;
2190 // Resolve image to image.
2192 enum ResolveImageToImageOptions{NO_OPTIONAL_OPERATION, COPY_MS_IMAGE_TO_MS_IMAGE, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE};
2193 class ResolveImageToImage : public CopiesAndBlittingTestInstance
2196 ResolveImageToImage (Context& context,
2198 const ResolveImageToImageOptions options);
2199 virtual tcu::TestStatus iterate (void);
2201 virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
2202 void copyMSImageToMSImage (void);
2204 Move<VkImage> m_multisampledImage;
2205 de::MovePtr<Allocation> m_multisampledImageAlloc;
2207 Move<VkImage> m_destination;
2208 de::MovePtr<Allocation> m_destinationImageAlloc;
2210 Move<VkImage> m_multisampledCopyImage;
2211 de::MovePtr<Allocation> m_multisampledCopyImageAlloc;
2213 const ResolveImageToImageOptions m_options;
2215 virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src,
2216 tcu::PixelBufferAccess dst,
2220 ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
2221 : CopiesAndBlittingTestInstance (context, params)
2222 , m_options (options)
2224 const VkSampleCountFlagBits rasterizationSamples = m_params.samples;
2226 if (!(context.getDeviceProperties().limits.framebufferColorSampleCounts & rasterizationSamples))
2227 throw tcu::NotSupportedError("Unsupported number of rasterization samples");
2229 const DeviceInterface& vk = context.getDeviceInterface();
2230 const VkDevice vkDevice = context.getDevice();
2231 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
2232 Allocator& memAlloc = m_context.getDefaultAllocator();
2234 const VkComponentMapping componentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
2235 Move<VkRenderPass> renderPass;
2237 Move<VkShaderModule> vertexShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("vert"), 0);
2238 Move<VkShaderModule> fragmentShaderModule = createShaderModule(vk, vkDevice, m_context.getBinaryCollection().get("frag"), 0);
2239 std::vector<tcu::Vec4> vertices;
2241 Move<VkBuffer> vertexBuffer;
2242 de::MovePtr<Allocation> vertexBufferAlloc;
2244 Move<VkPipelineLayout> pipelineLayout;
2245 Move<VkPipeline> graphicsPipeline;
2247 VkImageFormatProperties properties;
2248 if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2249 m_params.src.image.format,
2250 m_params.src.image.imageType,
2251 VK_IMAGE_TILING_OPTIMAL,
2252 VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
2253 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
2254 (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
2255 m_params.dst.image.format,
2256 m_params.dst.image.imageType,
2257 VK_IMAGE_TILING_OPTIMAL,
2258 VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0,
2259 &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
2261 TCU_THROW(NotSupportedError, "Format not supported");
2264 // Create color image.
2266 VkImageCreateInfo colorImageParams =
2268 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2269 DE_NULL, // const void* pNext;
2270 0u, // VkImageCreateFlags flags;
2271 m_params.src.image.imageType, // VkImageType imageType;
2272 m_params.src.image.format, // VkFormat format;
2273 getExtent3D(m_params.src.image), // VkExtent3D extent;
2274 1u, // deUint32 mipLevels;
2275 getArraySize(m_params.src.image), // deUint32 arrayLayers;
2276 rasterizationSamples, // VkSampleCountFlagBits samples;
2277 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2278 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, // VkImageUsageFlags usage;
2279 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2280 1u, // deUint32 queueFamilyIndexCount;
2281 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2282 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2285 m_multisampledImage = createImage(vk, vkDevice, &colorImageParams);
2287 // Allocate and bind color image memory.
2288 m_multisampledImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledImage), MemoryRequirement::Any);
2289 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledImage, m_multisampledImageAlloc->getMemory(), m_multisampledImageAlloc->getOffset()));
2293 case COPY_MS_IMAGE_TO_MS_IMAGE:
2295 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2296 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2297 // Allocate and bind color image memory.
2298 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2299 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2303 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2305 colorImageParams.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2306 colorImageParams.arrayLayers = getArraySize(m_params.dst.image);
2307 m_multisampledCopyImage = createImage(vk, vkDevice, &colorImageParams);
2308 // Allocate and bind color image memory.
2309 m_multisampledCopyImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_multisampledCopyImage), MemoryRequirement::Any);
2310 VK_CHECK(vk.bindImageMemory(vkDevice, *m_multisampledCopyImage, m_multisampledCopyImageAlloc->getMemory(), m_multisampledCopyImageAlloc->getOffset()));
2319 // Create destination image.
2321 const VkImageCreateInfo destinationImageParams =
2323 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
2324 DE_NULL, // const void* pNext;
2325 0u, // VkImageCreateFlags flags;
2326 m_params.dst.image.imageType, // VkImageType imageType;
2327 m_params.dst.image.format, // VkFormat format;
2328 getExtent3D(m_params.dst.image), // VkExtent3D extent;
2329 1u, // deUint32 mipLevels;
2330 getArraySize(m_params.dst.image), // deUint32 arraySize;
2331 VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
2332 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
2333 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2334 VK_IMAGE_USAGE_TRANSFER_DST_BIT, // VkImageUsageFlags usage;
2335 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2336 1u, // deUint32 queueFamilyCount;
2337 &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
2338 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
2341 m_destination = createImage(vk, vkDevice, &destinationImageParams);
2342 m_destinationImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *m_destination), MemoryRequirement::Any);
2343 VK_CHECK(vk.bindImageMemory(vkDevice, *m_destination, m_destinationImageAlloc->getMemory(), m_destinationImageAlloc->getOffset()));
2346 // Barriers for copying image to buffer
2347 VkImageMemoryBarrier srcImageBarrier =
2349 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2350 DE_NULL, // const void* pNext;
2351 0u, // VkAccessFlags srcAccessMask;
2352 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2353 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2354 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2355 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2356 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2357 m_multisampledImage.get(), // VkImage image;
2358 { // VkImageSubresourceRange subresourceRange;
2359 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
2360 0u, // deUint32 baseMipLevel;
2361 1u, // deUint32 mipLevels;
2362 0u, // deUint32 baseArraySlice;
2363 getArraySize(m_params.src.image) // deUint32 arraySize;
2367 // Create render pass.
2369 const VkAttachmentDescription attachmentDescriptions[1] =
2372 0u, // VkAttachmentDescriptionFlags flags;
2373 m_params.src.image.format, // VkFormat format;
2374 rasterizationSamples, // VkSampleCountFlagBits samples;
2375 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
2376 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
2377 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
2378 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
2379 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
2380 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
2384 const VkAttachmentReference colorAttachmentReference =
2386 0u, // deUint32 attachment;
2387 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
2390 const VkSubpassDescription subpassDescription =
2392 0u, // VkSubpassDescriptionFlags flags;
2393 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
2394 0u, // deUint32 inputAttachmentCount;
2395 DE_NULL, // const VkAttachmentReference* pInputAttachments;
2396 1u, // deUint32 colorAttachmentCount;
2397 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments;
2398 DE_NULL, // const VkAttachmentReference* pResolveAttachments;
2399 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
2400 0u, // deUint32 preserveAttachmentCount;
2401 DE_NULL // const VkAttachmentReference* pPreserveAttachments;
2404 const VkRenderPassCreateInfo renderPassParams =
2406 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
2407 DE_NULL, // const void* pNext;
2408 0u, // VkRenderPassCreateFlags flags;
2409 1u, // deUint32 attachmentCount;
2410 attachmentDescriptions, // const VkAttachmentDescription* pAttachments;
2411 1u, // deUint32 subpassCount;
2412 &subpassDescription, // const VkSubpassDescription* pSubpasses;
2413 0u, // deUint32 dependencyCount;
2414 DE_NULL // const VkSubpassDependency* pDependencies;
2417 renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
2420 // Create pipeline layout
2422 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
2424 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
2425 DE_NULL, // const void* pNext;
2426 0u, // VkPipelineLayoutCreateFlags flags;
2427 0u, // deUint32 setLayoutCount;
2428 DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
2429 0u, // deUint32 pushConstantRangeCount;
2430 DE_NULL // const VkPushConstantRange* pPushConstantRanges;
2433 pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
2436 // Create upper half triangle.
2438 const tcu::Vec4 a (-1.0, -1.0, 0.0, 1.0);
2439 const tcu::Vec4 b (1.0, -1.0, 0.0, 1.0);
2440 const tcu::Vec4 c (1.0, 1.0, 0.0, 1.0);
2442 vertices.push_back(a);
2443 vertices.push_back(c);
2444 vertices.push_back(b);
2447 // Create vertex buffer.
2449 const VkDeviceSize vertexDataSize = vertices.size() * sizeof(tcu::Vec4);
2450 const VkBufferCreateInfo vertexBufferParams =
2452 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
2453 DE_NULL, // const void* pNext;
2454 0u, // VkBufferCreateFlags flags;
2455 vertexDataSize, // VkDeviceSize size;
2456 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, // VkBufferUsageFlags usage;
2457 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
2458 1u, // deUint32 queueFamilyIndexCount;
2459 &queueFamilyIndex // const deUint32* pQueueFamilyIndices;
2462 vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
2463 vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
2465 VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
2467 // Load vertices into vertex buffer.
2468 deMemcpy(vertexBufferAlloc->getHostPtr(), vertices.data(), (size_t)vertexDataSize);
2469 flushMappedMemoryRange(vk, vkDevice, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset(), vertexDataSize);
2473 Move<VkFramebuffer> framebuffer;
2474 Move<VkImageView> sourceAttachmentView;
2475 //const VkExtent3D extent3D = getExtent3D(m_params.src.image); TODO
2477 // Create color attachment view.
2479 const VkImageViewCreateInfo colorAttachmentViewParams =
2481 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
2482 DE_NULL, // const void* pNext;
2483 0u, // VkImageViewCreateFlags flags;
2484 *m_multisampledImage, // VkImage image;
2485 VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
2486 m_params.src.image.format, // VkFormat format;
2487 componentMappingRGBA, // VkComponentMapping components;
2488 { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
2490 sourceAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
2493 // Create framebuffer
2495 const VkImageView attachments[1] =
2497 *sourceAttachmentView,
2500 const VkFramebufferCreateInfo framebufferParams =
2502 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
2503 DE_NULL, // const void* pNext;
2504 0u, // VkFramebufferCreateFlags flags;
2505 *renderPass, // VkRenderPass renderPass;
2506 1u, // deUint32 attachmentCount;
2507 attachments, // const VkImageView* pAttachments;
2508 m_params.src.image.extent.width, // deUint32 width;
2509 m_params.src.image.extent.height, // deUint32 height;
2510 1u // deUint32 layers;
2513 framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
2518 const VkPipelineShaderStageCreateInfo shaderStageParams[2] =
2521 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2522 DE_NULL, // const void* pNext;
2523 0u, // VkPipelineShaderStageCreateFlags flags;
2524 VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
2525 *vertexShaderModule, // VkShaderModule module;
2526 "main", // const char* pName;
2527 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2530 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
2531 DE_NULL, // const void* pNext;
2532 0u, // VkPipelineShaderStageCreateFlags flags;
2533 VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
2534 *fragmentShaderModule, // VkShaderModule module;
2535 "main", // const char* pName;
2536 DE_NULL // const VkSpecializationInfo* pSpecializationInfo;
2540 const VkVertexInputBindingDescription vertexInputBindingDescription =
2542 0u, // deUint32 binding;
2543 sizeof(tcu::Vec4), // deUint32 stride;
2544 VK_VERTEX_INPUT_RATE_VERTEX // VkVertexInputRate inputRate;
2547 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[1] =
2550 0u, // deUint32 location;
2551 0u, // deUint32 binding;
2552 VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
2553 0u // deUint32 offset;
2557 const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
2559 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
2560 DE_NULL, // const void* pNext;
2561 0u, // VkPipelineVertexInputStateCreateFlags flags;
2562 1u, // deUint32 vertexBindingDescriptionCount;
2563 &vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
2564 1u, // deUint32 vertexAttributeDescriptionCount;
2565 vertexInputAttributeDescriptions // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
2568 const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
2570 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
2571 DE_NULL, // const void* pNext;
2572 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
2573 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
2574 false // VkBool32 primitiveRestartEnable;
2577 const VkViewport viewport =
2581 (float)m_params.src.image.extent.width, // float width;
2582 (float)m_params.src.image.extent.height,// float height;
2583 0.0f, // float minDepth;
2584 1.0f // float maxDepth;
2587 const VkRect2D scissor =
2589 { 0, 0 }, // VkOffset2D offset;
2590 { m_params.src.image.extent.width, m_params.src.image.extent.height } // VkExtent2D extent;
2593 const VkPipelineViewportStateCreateInfo viewportStateParams =
2595 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
2596 DE_NULL, // const void* pNext;
2597 0u, // VkPipelineViewportStateCreateFlags flags;
2598 1u, // deUint32 viewportCount;
2599 &viewport, // const VkViewport* pViewports;
2600 1u, // deUint32 scissorCount;
2601 &scissor // const VkRect2D* pScissors;
2604 const VkPipelineRasterizationStateCreateInfo rasterStateParams =
2606 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
2607 DE_NULL, // const void* pNext;
2608 0u, // VkPipelineRasterizationStateCreateFlags flags;
2609 false, // VkBool32 depthClampEnable;
2610 false, // VkBool32 rasterizerDiscardEnable;
2611 VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
2612 VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
2613 VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
2614 VK_FALSE, // VkBool32 depthBiasEnable;
2615 0.0f, // float depthBiasConstantFactor;
2616 0.0f, // float depthBiasClamp;
2617 0.0f, // float depthBiasSlopeFactor;
2618 1.0f // float lineWidth;
2621 const VkPipelineMultisampleStateCreateInfo multisampleStateParams =
2623 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
2624 DE_NULL, // const void* pNext;
2625 0u, // VkPipelineMultisampleStateCreateFlags flags;
2626 rasterizationSamples, // VkSampleCountFlagBits rasterizationSamples;
2627 VK_FALSE, // VkBool32 sampleShadingEnable;
2628 0.0f, // float minSampleShading;
2629 DE_NULL, // const VkSampleMask* pSampleMask;
2630 VK_FALSE, // VkBool32 alphaToCoverageEnable;
2631 VK_FALSE // VkBool32 alphaToOneEnable;
2634 const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
2636 false, // VkBool32 blendEnable;
2637 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendColor;
2638 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendColor;
2639 VK_BLEND_OP_ADD, // VkBlendOp blendOpColor;
2640 VK_BLEND_FACTOR_ONE, // VkBlend srcBlendAlpha;
2641 VK_BLEND_FACTOR_ZERO, // VkBlend destBlendAlpha;
2642 VK_BLEND_OP_ADD, // VkBlendOp blendOpAlpha;
2643 (VK_COLOR_COMPONENT_R_BIT |
2644 VK_COLOR_COMPONENT_G_BIT |
2645 VK_COLOR_COMPONENT_B_BIT |
2646 VK_COLOR_COMPONENT_A_BIT) // VkChannelFlags channelWriteMask;
2649 const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
2651 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
2652 DE_NULL, // const void* pNext;
2653 0u, // VkPipelineColorBlendStateCreateFlags flags;
2654 false, // VkBool32 logicOpEnable;
2655 VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
2656 1u, // deUint32 attachmentCount;
2657 &colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
2658 { 0.0f, 0.0f, 0.0f, 0.0f } // float blendConstants[4];
2661 const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
2663 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
2664 DE_NULL, // const void* pNext;
2665 0u, // VkPipelineCreateFlags flags;
2666 2u, // deUint32 stageCount;
2667 shaderStageParams, // const VkPipelineShaderStageCreateInfo* pStages;
2668 &vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
2669 &inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
2670 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
2671 &viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState;
2672 &rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
2673 &multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
2674 DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
2675 &colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
2676 DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
2677 *pipelineLayout, // VkPipelineLayout layout;
2678 *renderPass, // VkRenderPass renderPass;
2679 0u, // deUint32 subpass;
2680 0u, // VkPipeline basePipelineHandle;
2681 0u // deInt32 basePipelineIndex;
2684 graphicsPipeline = createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
2687 // Create command buffer
2689 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2691 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2692 DE_NULL, // const void* pNext;
2693 0u, // VkCommandBufferUsageFlags flags;
2694 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2697 const VkClearValue clearValues[1] =
2699 makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
2702 const VkRenderPassBeginInfo renderPassBeginInfo =
2704 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
2705 DE_NULL, // const void* pNext;
2706 *renderPass, // VkRenderPass renderPass;
2707 *framebuffer, // VkFramebuffer framebuffer;
2710 { m_params.src.image.extent.width, m_params.src.image.extent.height }
2711 }, // VkRect2D renderArea;
2712 1u, // deUint32 clearValueCount;
2713 clearValues // const VkClearValue* pClearValues;
2716 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2717 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);
2718 vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
2720 const VkDeviceSize vertexBufferOffset = 0u;
2722 vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
2723 vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer.get(), &vertexBufferOffset);
2724 vk.cmdDraw(*m_cmdBuffer, (deUint32)vertices.size(), 1, 0, 0);
2726 vk.cmdEndRenderPass(*m_cmdBuffer);
2727 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2732 const VkQueue queue = m_context.getUniversalQueue();
2733 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
2738 tcu::TestStatus ResolveImageToImage::iterate (void)
2740 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2741 const tcu::TextureFormat dstTcuFormat = mapVkFormat(m_params.dst.image.format);
2743 // upload the destination image
2744 m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
2745 (int)m_params.dst.image.extent.width,
2746 (int)m_params.dst.image.extent.height,
2747 (int)m_params.dst.image.extent.depth));
2748 generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
2749 uploadImage(m_destinationTextureLevel->getAccess(), m_destination.get(), m_params.dst.image);
2751 m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(srcTcuFormat,
2752 (int)m_params.src.image.extent.width,
2753 (int)m_params.src.image.extent.height,
2754 (int)m_params.dst.image.extent.depth));
2756 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);
2757 generateExpectedResult();
2761 case COPY_MS_IMAGE_TO_MS_IMAGE:
2762 case COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE:
2763 copyMSImageToMSImage();
2769 const DeviceInterface& vk = m_context.getDeviceInterface();
2770 const VkDevice vkDevice = m_context.getDevice();
2771 const VkQueue queue = m_context.getUniversalQueue();
2773 std::vector<VkImageResolve> imageResolves;
2774 for (deUint32 i = 0; i < m_params.regions.size(); i++)
2775 imageResolves.push_back(m_params.regions[i].imageResolve);
2777 const VkImageMemoryBarrier imageBarriers[] =
2781 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2782 DE_NULL, // const void* pNext;
2783 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2784 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2785 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2786 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2787 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2788 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2789 m_multisampledImage.get(), // VkImage image;
2790 { // VkImageSubresourceRange subresourceRange;
2791 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2792 0u, // deUint32 baseMipLevel;
2793 1u, // deUint32 mipLevels;
2794 0u, // deUint32 baseArraySlice;
2795 getArraySize(m_params.dst.image) // deUint32 arraySize;
2798 // destination image
2800 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2801 DE_NULL, // const void* pNext;
2802 0u, // VkAccessFlags srcAccessMask;
2803 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2804 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2805 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2806 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2807 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2808 m_destination.get(), // VkImage image;
2809 { // VkImageSubresourceRange subresourceRange;
2810 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2811 0u, // deUint32 baseMipLevel;
2812 1u, // deUint32 mipLevels;
2813 0u, // deUint32 baseArraySlice;
2814 getArraySize(m_params.dst.image) // deUint32 arraySize;
2819 const VkImageMemoryBarrier postImageBarrier =
2821 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2822 DE_NULL, // const void* pNext;
2823 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2824 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2825 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2826 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2827 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2828 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2829 m_destination.get(), // VkImage image;
2830 { // VkImageSubresourceRange subresourceRange;
2831 getAspectFlags(dstTcuFormat), // VkImageAspectFlags aspectMask;
2832 0u, // deUint32 baseMipLevel;
2833 1u, // deUint32 mipLevels;
2834 0u, // deUint32 baseArraySlice;
2835 getArraySize(m_params.dst.image) // deUint32 arraySize;
2839 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2841 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2842 DE_NULL, // const void* pNext;
2843 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2844 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2847 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
2848 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);
2849 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());
2850 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);
2851 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2852 submitCommandsAndWait(vk, vkDevice, queue, *m_cmdBuffer);
2854 de::MovePtr<tcu::TextureLevel> resultTextureLevel = readImage(*m_destination, m_params.dst.image);
2856 return checkTestResult(resultTextureLevel->getAccess());
2859 tcu::TestStatus ResolveImageToImage::checkTestResult (tcu::ConstPixelBufferAccess result)
2861 const tcu::ConstPixelBufferAccess expected = m_expectedTextureLevel->getAccess();
2862 const float fuzzyThreshold = 0.01f;
2864 for (int arrayLayerNdx = 0; arrayLayerNdx < (int)getArraySize(m_params.dst.image); ++arrayLayerNdx)
2866 const tcu::ConstPixelBufferAccess expectedSub = getSubregion (expected, 0, 0, arrayLayerNdx, expected.getWidth(), expected.getHeight(), 1u);
2867 const tcu::ConstPixelBufferAccess resultSub = getSubregion (result, 0, 0, arrayLayerNdx, result.getWidth(), result.getHeight(), 1u);
2868 if (!tcu::fuzzyCompare(m_context.getTestContext().getLog(), "Compare", "Result comparsion", expectedSub, resultSub, fuzzyThreshold, tcu::COMPARE_LOG_RESULT))
2869 return tcu::TestStatus::fail("CopiesAndBlitting test");
2872 return tcu::TestStatus::pass("CopiesAndBlitting test");
2875 void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
2877 VkOffset3D srcOffset = region.imageResolve.srcOffset;
2878 srcOffset.z = region.imageResolve.srcSubresource.baseArrayLayer;
2879 VkOffset3D dstOffset = region.imageResolve.dstOffset;
2880 dstOffset.z = region.imageResolve.dstSubresource.baseArrayLayer;
2881 VkExtent3D extent = region.imageResolve.extent;
2883 const tcu::ConstPixelBufferAccess srcSubRegion = getSubregion (src, srcOffset.x, srcOffset.y, srcOffset.z, extent.width, extent.height, extent.depth);
2884 // CopyImage acts like a memcpy. Replace the destination format with the srcformat to use a memcpy.
2885 const tcu::PixelBufferAccess dstWithSrcFormat (srcSubRegion.getFormat(), dst.getSize(), dst.getDataPtr());
2886 const tcu::PixelBufferAccess dstSubRegion = getSubregion (dstWithSrcFormat, dstOffset.x, dstOffset.y, dstOffset.z, extent.width, extent.height, extent.depth);
2888 tcu::copy(dstSubRegion, srcSubRegion);
2891 void ResolveImageToImage::copyMSImageToMSImage (void)
2893 const DeviceInterface& vk = m_context.getDeviceInterface();
2894 const VkDevice vkDevice = m_context.getDevice();
2895 const VkQueue queue = m_context.getUniversalQueue();
2896 const tcu::TextureFormat srcTcuFormat = mapVkFormat(m_params.src.image.format);
2897 std::vector<VkImageCopy> imageCopies;
2899 for (deUint32 layerNdx = 0; layerNdx < getArraySize(m_params.dst.image); ++layerNdx)
2901 const VkImageSubresourceLayers sourceSubresourceLayers =
2903 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2904 0u, // uint32_t mipLevel;
2905 0u, // uint32_t baseArrayLayer;
2906 1u // uint32_t layerCount;
2909 const VkImageSubresourceLayers destinationSubresourceLayers =
2911 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;//getAspectFlags(dstTcuFormat)
2912 0u, // uint32_t mipLevel;
2913 layerNdx, // uint32_t baseArrayLayer;
2914 1u // uint32_t layerCount;
2917 const VkImageCopy imageCopy =
2919 sourceSubresourceLayers, // VkImageSubresourceLayers srcSubresource;
2920 {0, 0, 0}, // VkOffset3D srcOffset;
2921 destinationSubresourceLayers, // VkImageSubresourceLayers dstSubresource;
2922 {0, 0, 0}, // VkOffset3D dstOffset;
2923 getExtent3D(m_params.src.image), // VkExtent3D extent;
2925 imageCopies.push_back(imageCopy);
2928 const VkImageMemoryBarrier imageBarriers[] =
2932 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2933 DE_NULL, // const void* pNext;
2934 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags srcAccessMask;
2935 VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
2936 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout oldLayout;
2937 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
2938 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2939 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2940 m_multisampledImage.get(), // VkImage image;
2941 { // VkImageSubresourceRange subresourceRange;
2942 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2943 0u, // deUint32 baseMipLevel;
2944 1u, // deUint32 mipLevels;
2945 0u, // deUint32 baseArraySlice;
2946 getArraySize(m_params.src.image) // deUint32 arraySize;
2949 // destination image
2951 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2952 DE_NULL, // const void* pNext;
2953 0, // VkAccessFlags srcAccessMask;
2954 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
2955 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
2956 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
2957 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2958 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2959 m_multisampledCopyImage.get(), // VkImage image;
2960 { // VkImageSubresourceRange subresourceRange;
2961 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2962 0u, // deUint32 baseMipLevel;
2963 1u, // deUint32 mipLevels;
2964 0u, // deUint32 baseArraySlice;
2965 getArraySize(m_params.dst.image) // deUint32 arraySize;
2970 const VkImageMemoryBarrier postImageBarriers =
2973 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
2974 DE_NULL, // const void* pNext;
2975 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2976 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags dstAccessMask;
2977 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
2978 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout newLayout;
2979 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2980 VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
2981 m_multisampledCopyImage.get(), // VkImage image;
2982 { // VkImageSubresourceRange subresourceRange;
2983 getAspectFlags(srcTcuFormat), // VkImageAspectFlags aspectMask;
2984 0u, // deUint32 baseMipLevel;
2985 1u, // deUint32 mipLevels;
2986 0u, // deUint32 baseArraySlice;
2987 getArraySize(m_params.dst.image) // deUint32 arraySize;
2991 const VkCommandBufferBeginInfo cmdBufferBeginInfo =
2993 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
2994 DE_NULL, // const void* pNext;
2995 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
2996 (const VkCommandBufferInheritanceInfo*)DE_NULL,
2999 VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
3000 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);
3001 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());
3002 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);
3003 VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
3005 submitCommandsAndWait (vk, vkDevice, queue, *m_cmdBuffer);
3007 m_multisampledImage = m_multisampledCopyImage;
3010 class ResolveImageToImageTestCase : public vkt::TestCase
3013 ResolveImageToImageTestCase (tcu::TestContext& testCtx,
3014 const std::string& name,
3015 const std::string& description,
3016 const TestParams params,
3017 const ResolveImageToImageOptions options = NO_OPTIONAL_OPERATION)
3018 : vkt::TestCase (testCtx, name, description)
3020 , m_options (options)
3022 virtual void initPrograms (SourceCollections& programCollection) const;
3024 virtual TestInstance* createInstance (Context& context) const
3026 return new ResolveImageToImage(context, m_params, m_options);
3029 TestParams m_params;
3030 const ResolveImageToImageOptions m_options;
3033 void ResolveImageToImageTestCase::initPrograms (SourceCollections& programCollection) const
3035 programCollection.glslSources.add("vert") << glu::VertexSource(
3037 "layout (location = 0) in highp vec4 a_position;\n"
3040 " gl_Position = a_position;\n"
3044 programCollection.glslSources.add("frag") << glu::FragmentSource(
3046 "layout (location = 0) out highp vec4 o_color;\n"
3049 " o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
3053 std::string getSampleCountCaseName (VkSampleCountFlagBits sampleFlag)
3055 return de::toLower(de::toString(getSampleCountFlagsStr(sampleFlag)).substr(16));
3058 std::string getFormatCaseName (VkFormat format)
3060 return de::toLower(de::toString(getFormatStr(format)).substr(10));
3063 void addCopyImageTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3064 tcu::TestContext& testCtx,
3067 const VkFormat compatibleFormats8Bit[] =
3069 VK_FORMAT_R4G4_UNORM_PACK8,
3072 VK_FORMAT_R8_USCALED,
3073 VK_FORMAT_R8_SSCALED,
3080 const VkFormat compatibleFormats16Bit[] =
3082 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3083 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3084 VK_FORMAT_R5G6B5_UNORM_PACK16,
3085 VK_FORMAT_B5G6R5_UNORM_PACK16,
3086 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3087 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3088 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3089 VK_FORMAT_R8G8_UNORM,
3090 VK_FORMAT_R8G8_SNORM,
3091 VK_FORMAT_R8G8_USCALED,
3092 VK_FORMAT_R8G8_SSCALED,
3093 VK_FORMAT_R8G8_UINT,
3094 VK_FORMAT_R8G8_SINT,
3095 VK_FORMAT_R8G8_SRGB,
3096 VK_FORMAT_R16_UNORM,
3097 VK_FORMAT_R16_SNORM,
3098 VK_FORMAT_R16_USCALED,
3099 VK_FORMAT_R16_SSCALED,
3102 VK_FORMAT_R16_SFLOAT,
3106 const VkFormat compatibleFormats24Bit[] =
3108 VK_FORMAT_R8G8B8_UNORM,
3109 VK_FORMAT_R8G8B8_SNORM,
3110 VK_FORMAT_R8G8B8_USCALED,
3111 VK_FORMAT_R8G8B8_SSCALED,
3112 VK_FORMAT_R8G8B8_UINT,
3113 VK_FORMAT_R8G8B8_SINT,
3114 VK_FORMAT_R8G8B8_SRGB,
3115 VK_FORMAT_B8G8R8_UNORM,
3116 VK_FORMAT_B8G8R8_SNORM,
3117 VK_FORMAT_B8G8R8_USCALED,
3118 VK_FORMAT_B8G8R8_SSCALED,
3119 VK_FORMAT_B8G8R8_UINT,
3120 VK_FORMAT_B8G8R8_SINT,
3121 VK_FORMAT_B8G8R8_SRGB,
3125 const VkFormat compatibleFormats32Bit[] =
3127 VK_FORMAT_R8G8B8A8_UNORM,
3128 VK_FORMAT_R8G8B8A8_SNORM,
3129 VK_FORMAT_R8G8B8A8_USCALED,
3130 VK_FORMAT_R8G8B8A8_SSCALED,
3131 VK_FORMAT_R8G8B8A8_UINT,
3132 VK_FORMAT_R8G8B8A8_SINT,
3133 VK_FORMAT_R8G8B8A8_SRGB,
3134 VK_FORMAT_B8G8R8A8_UNORM,
3135 VK_FORMAT_B8G8R8A8_SNORM,
3136 VK_FORMAT_B8G8R8A8_USCALED,
3137 VK_FORMAT_B8G8R8A8_SSCALED,
3138 VK_FORMAT_B8G8R8A8_UINT,
3139 VK_FORMAT_B8G8R8A8_SINT,
3140 VK_FORMAT_B8G8R8A8_SRGB,
3141 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3142 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3143 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3144 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3145 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3146 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3147 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3148 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3149 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3150 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3151 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3152 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3153 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3154 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3155 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3156 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3157 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3158 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3159 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3160 VK_FORMAT_R16G16_UNORM,
3161 VK_FORMAT_R16G16_SNORM,
3162 VK_FORMAT_R16G16_USCALED,
3163 VK_FORMAT_R16G16_SSCALED,
3164 VK_FORMAT_R16G16_UINT,
3165 VK_FORMAT_R16G16_SINT,
3166 VK_FORMAT_R16G16_SFLOAT,
3169 VK_FORMAT_R32_SFLOAT,
3173 const VkFormat compatibleFormats48Bit[] =
3175 VK_FORMAT_R16G16B16_UNORM,
3176 VK_FORMAT_R16G16B16_SNORM,
3177 VK_FORMAT_R16G16B16_USCALED,
3178 VK_FORMAT_R16G16B16_SSCALED,
3179 VK_FORMAT_R16G16B16_UINT,
3180 VK_FORMAT_R16G16B16_SINT,
3181 VK_FORMAT_R16G16B16_SFLOAT,
3185 const VkFormat compatibleFormats64Bit[] =
3187 VK_FORMAT_R16G16B16A16_UNORM,
3188 VK_FORMAT_R16G16B16A16_SNORM,
3189 VK_FORMAT_R16G16B16A16_USCALED,
3190 VK_FORMAT_R16G16B16A16_SSCALED,
3191 VK_FORMAT_R16G16B16A16_UINT,
3192 VK_FORMAT_R16G16B16A16_SINT,
3193 VK_FORMAT_R16G16B16A16_SFLOAT,
3194 VK_FORMAT_R32G32_UINT,
3195 VK_FORMAT_R32G32_SINT,
3196 VK_FORMAT_R32G32_SFLOAT,
3199 VK_FORMAT_R64_SFLOAT,
3203 const VkFormat compatibleFormats96Bit[] =
3205 VK_FORMAT_R32G32B32_UINT,
3206 VK_FORMAT_R32G32B32_SINT,
3207 VK_FORMAT_R32G32B32_SFLOAT,
3211 const VkFormat compatibleFormats128Bit[] =
3213 VK_FORMAT_R32G32B32A32_UINT,
3214 VK_FORMAT_R32G32B32A32_SINT,
3215 VK_FORMAT_R32G32B32A32_SFLOAT,
3216 VK_FORMAT_R64G64_UINT,
3217 VK_FORMAT_R64G64_SINT,
3218 VK_FORMAT_R64G64_SFLOAT,
3222 const VkFormat compatibleFormats192Bit[] =
3224 VK_FORMAT_R64G64B64_UINT,
3225 VK_FORMAT_R64G64B64_SINT,
3226 VK_FORMAT_R64G64B64_SFLOAT,
3230 const VkFormat compatibleFormats256Bit[] =
3232 VK_FORMAT_R64G64B64A64_UINT,
3233 VK_FORMAT_R64G64B64A64_SINT,
3234 VK_FORMAT_R64G64B64A64_SFLOAT,
3239 const VkFormat* colorImageFormatsToTest[] =
3241 compatibleFormats8Bit,
3242 compatibleFormats16Bit,
3243 compatibleFormats24Bit,
3244 compatibleFormats32Bit,
3245 compatibleFormats48Bit,
3246 compatibleFormats64Bit,
3247 compatibleFormats96Bit,
3248 compatibleFormats128Bit,
3249 compatibleFormats192Bit,
3250 compatibleFormats256Bit,
3252 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3254 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3256 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex];
3257 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3259 params.src.image.format = compatibleFormats[srcFormatIndex];
3260 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3262 params.dst.image.format = compatibleFormats[dstFormatIndex];
3264 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
3267 std::ostringstream testName;
3268 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3269 std::ostringstream description;
3270 description << "Copy from src " << params.src.image.format << " to dst " << params.dst.image.format;
3272 testCaseGroup->addChild(new CopyImageToImageTestCase(testCtx, testName.str(), description.str(), params));
3278 void addBlittingTestsAllFormats (tcu::TestCaseGroup* testCaseGroup,
3279 tcu::TestContext& testCtx,
3282 // Test Image formats.
3283 const VkFormat compatibleFormatsUInts[] =
3286 VK_FORMAT_R8G8_UINT,
3287 VK_FORMAT_R8G8B8_UINT,
3288 VK_FORMAT_B8G8R8_UINT,
3289 VK_FORMAT_R8G8B8A8_UINT,
3290 VK_FORMAT_B8G8R8A8_UINT,
3291 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3292 VK_FORMAT_A2R10G10B10_UINT_PACK32,
3293 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3295 VK_FORMAT_R16G16_UINT,
3296 VK_FORMAT_R16G16B16_UINT,
3297 VK_FORMAT_R16G16B16A16_UINT,
3299 VK_FORMAT_R32G32_UINT,
3300 VK_FORMAT_R32G32B32_UINT,
3301 VK_FORMAT_R32G32B32A32_UINT,
3303 VK_FORMAT_R64G64_UINT,
3304 VK_FORMAT_R64G64B64_UINT,
3305 VK_FORMAT_R64G64B64A64_UINT,
3309 const VkFormat compatibleFormatsSInts[] =
3312 VK_FORMAT_R8G8_SINT,
3313 VK_FORMAT_R8G8B8_SINT,
3314 VK_FORMAT_B8G8R8_SINT,
3315 VK_FORMAT_R8G8B8A8_SINT,
3316 VK_FORMAT_B8G8R8A8_SINT,
3317 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3318 VK_FORMAT_A2R10G10B10_SINT_PACK32,
3319 VK_FORMAT_A2B10G10R10_SINT_PACK32,
3321 VK_FORMAT_R16G16_SINT,
3322 VK_FORMAT_R16G16B16_SINT,
3323 VK_FORMAT_R16G16B16A16_SINT,
3325 VK_FORMAT_R32G32_SINT,
3326 VK_FORMAT_R32G32B32_SINT,
3327 VK_FORMAT_R32G32B32A32_SINT,
3329 VK_FORMAT_R64G64_SINT,
3330 VK_FORMAT_R64G64B64_SINT,
3331 VK_FORMAT_R64G64B64A64_SINT,
3335 const VkFormat compatibleFormatsFloats[] =
3337 VK_FORMAT_R4G4_UNORM_PACK8,
3338 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3339 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3340 VK_FORMAT_R5G6B5_UNORM_PACK16,
3341 VK_FORMAT_B5G6R5_UNORM_PACK16,
3342 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3343 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3344 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3347 VK_FORMAT_R8_USCALED,
3348 VK_FORMAT_R8_SSCALED,
3349 VK_FORMAT_R8G8_UNORM,
3350 VK_FORMAT_R8G8_SNORM,
3351 VK_FORMAT_R8G8_USCALED,
3352 VK_FORMAT_R8G8_SSCALED,
3353 VK_FORMAT_R8G8B8_UNORM,
3354 VK_FORMAT_R8G8B8_SNORM,
3355 VK_FORMAT_R8G8B8_USCALED,
3356 VK_FORMAT_R8G8B8_SSCALED,
3357 VK_FORMAT_B8G8R8_UNORM,
3358 VK_FORMAT_B8G8R8_SNORM,
3359 VK_FORMAT_B8G8R8_USCALED,
3360 VK_FORMAT_B8G8R8_SSCALED,
3361 VK_FORMAT_R8G8B8A8_UNORM,
3362 VK_FORMAT_R8G8B8A8_SNORM,
3363 VK_FORMAT_R8G8B8A8_USCALED,
3364 VK_FORMAT_R8G8B8A8_SSCALED,
3365 VK_FORMAT_B8G8R8A8_UNORM,
3366 VK_FORMAT_B8G8R8A8_SNORM,
3367 VK_FORMAT_B8G8R8A8_USCALED,
3368 VK_FORMAT_B8G8R8A8_SSCALED,
3369 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3370 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3371 VK_FORMAT_A8B8G8R8_USCALED_PACK32,
3372 VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
3373 VK_FORMAT_A2R10G10B10_UNORM_PACK32,
3374 VK_FORMAT_A2R10G10B10_SNORM_PACK32,
3375 VK_FORMAT_A2R10G10B10_USCALED_PACK32,
3376 VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
3377 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3378 VK_FORMAT_A2B10G10R10_SNORM_PACK32,
3379 VK_FORMAT_A2B10G10R10_USCALED_PACK32,
3380 VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
3381 VK_FORMAT_R16_UNORM,
3382 VK_FORMAT_R16_SNORM,
3383 VK_FORMAT_R16_USCALED,
3384 VK_FORMAT_R16_SSCALED,
3385 VK_FORMAT_R16_SFLOAT,
3386 VK_FORMAT_R16G16_UNORM,
3387 VK_FORMAT_R16G16_SNORM,
3388 VK_FORMAT_R16G16_USCALED,
3389 VK_FORMAT_R16G16_SSCALED,
3390 VK_FORMAT_R16G16_SFLOAT,
3391 VK_FORMAT_R16G16B16_UNORM,
3392 VK_FORMAT_R16G16B16_SNORM,
3393 VK_FORMAT_R16G16B16_USCALED,
3394 VK_FORMAT_R16G16B16_SSCALED,
3395 VK_FORMAT_R16G16B16_SFLOAT,
3396 VK_FORMAT_R16G16B16A16_UNORM,
3397 VK_FORMAT_R16G16B16A16_SNORM,
3398 VK_FORMAT_R16G16B16A16_USCALED,
3399 VK_FORMAT_R16G16B16A16_SSCALED,
3400 VK_FORMAT_R16G16B16A16_SFLOAT,
3401 VK_FORMAT_R32_SFLOAT,
3402 VK_FORMAT_R32G32_SFLOAT,
3403 VK_FORMAT_R32G32B32_SFLOAT,
3404 VK_FORMAT_R32G32B32A32_SFLOAT,
3405 VK_FORMAT_R64_SFLOAT,
3406 VK_FORMAT_R64G64_SFLOAT,
3407 VK_FORMAT_R64G64B64_SFLOAT,
3408 VK_FORMAT_R64G64B64A64_SFLOAT,
3409 // VK_FORMAT_B10G11R11_UFLOAT_PACK32,
3410 // VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
3411 // VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3412 // VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3413 // VK_FORMAT_BC2_UNORM_BLOCK,
3414 // VK_FORMAT_BC3_UNORM_BLOCK,
3415 // VK_FORMAT_BC4_UNORM_BLOCK,
3416 // VK_FORMAT_BC4_SNORM_BLOCK,
3417 // VK_FORMAT_BC5_UNORM_BLOCK,
3418 // VK_FORMAT_BC5_SNORM_BLOCK,
3419 // VK_FORMAT_BC6H_UFLOAT_BLOCK,
3420 // VK_FORMAT_BC6H_SFLOAT_BLOCK,
3421 // VK_FORMAT_BC7_UNORM_BLOCK,
3422 // VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3423 // VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3424 // VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3425 // VK_FORMAT_EAC_R11_UNORM_BLOCK,
3426 // VK_FORMAT_EAC_R11_SNORM_BLOCK,
3427 // VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3428 // VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3429 // VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3430 // VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3431 // VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3432 // VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3433 // VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3434 // VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3435 // VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3436 // VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3437 // VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3438 // VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3439 // VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3440 // VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3441 // VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3442 // VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3446 const VkFormat compatibleFormatsSrgb[] =
3449 VK_FORMAT_R8G8_SRGB,
3450 VK_FORMAT_R8G8B8_SRGB,
3451 VK_FORMAT_B8G8R8_SRGB,
3452 VK_FORMAT_R8G8B8A8_SRGB,
3453 VK_FORMAT_B8G8R8A8_SRGB,
3454 VK_FORMAT_A8B8G8R8_SRGB_PACK32,
3455 // VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3456 // VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3457 // VK_FORMAT_BC2_SRGB_BLOCK,
3458 // VK_FORMAT_BC3_SRGB_BLOCK,
3459 // VK_FORMAT_BC7_SRGB_BLOCK,
3460 // VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3461 // VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3462 // VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3463 // VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3464 // VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3465 // VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3466 // VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3467 // VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3468 // VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3469 // VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3470 // VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3471 // VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3472 // VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3473 // VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3474 // VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3475 // VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3476 // VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3482 const VkFormat* compatibleFormats;
3483 const bool onlyNearest;
3484 } colorImageFormatsToTest[] =
3486 { compatibleFormatsUInts, true },
3487 { compatibleFormatsSInts, true },
3488 { compatibleFormatsFloats, false },
3489 { compatibleFormatsSrgb, false },
3491 const size_t numOfColorImageFormatsToTest = DE_LENGTH_OF_ARRAY(colorImageFormatsToTest);
3493 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < numOfColorImageFormatsToTest; ++compatibleFormatsIndex)
3495 const VkFormat* compatibleFormats = colorImageFormatsToTest[compatibleFormatsIndex].compatibleFormats;
3496 const bool onlyNearest = colorImageFormatsToTest[compatibleFormatsIndex].onlyNearest;
3497 for (size_t srcFormatIndex = 0; compatibleFormats[srcFormatIndex] != VK_FORMAT_UNDEFINED; ++srcFormatIndex)
3499 params.src.image.format = compatibleFormats[srcFormatIndex];
3500 for (size_t dstFormatIndex = 0; compatibleFormats[dstFormatIndex] != VK_FORMAT_UNDEFINED; ++dstFormatIndex)
3502 params.dst.image.format = compatibleFormats[dstFormatIndex];
3504 if (!isSupportedByFramework(params.src.image.format) || !isSupportedByFramework(params.dst.image.format))
3507 std::ostringstream testName;
3508 testName << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3509 std::ostringstream description;
3510 description << "Blit image from src " << params.src.image.format << " to dst " << params.dst.image.format;
3512 params.filter = VK_FILTER_NEAREST;
3513 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_nearest", description.str(), params));
3517 params.filter = VK_FILTER_LINEAR;
3518 testCaseGroup->addChild(new BlittingTestCase(testCtx, testName.str() + "_linear", description.str(), params));
3527 tcu::TestCaseGroup* createCopiesAndBlittingTests (tcu::TestContext& testCtx)
3529 de::MovePtr<tcu::TestCaseGroup> copiesAndBlittingTests (new tcu::TestCaseGroup(testCtx, "copy_and_blit", "Copies And Blitting Tests"));
3531 de::MovePtr<tcu::TestCaseGroup> imageToImageTests (new tcu::TestCaseGroup(testCtx, "image_to_image", "Copy from image to image"));
3532 de::MovePtr<tcu::TestCaseGroup> imgToImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Copy from image to image simple tests"));
3533 de::MovePtr<tcu::TestCaseGroup> imgToImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Copy from image to image with all compatible formats"));
3534 de::MovePtr<tcu::TestCaseGroup> imgToImg3dImagesTests (new tcu::TestCaseGroup(testCtx, "3d_images", "Coping operations on 3d images"));
3536 de::MovePtr<tcu::TestCaseGroup> imageToBufferTests (new tcu::TestCaseGroup(testCtx, "image_to_buffer", "Copy from image to buffer"));
3537 de::MovePtr<tcu::TestCaseGroup> bufferToImageTests (new tcu::TestCaseGroup(testCtx, "buffer_to_image", "Copy from buffer to image"));
3538 de::MovePtr<tcu::TestCaseGroup> bufferToBufferTests (new tcu::TestCaseGroup(testCtx, "buffer_to_buffer", "Copy from buffer to buffer"));
3540 de::MovePtr<tcu::TestCaseGroup> blittingImageTests (new tcu::TestCaseGroup(testCtx, "blit_image", "Blitting image"));
3541 de::MovePtr<tcu::TestCaseGroup> blitImgSimpleTests (new tcu::TestCaseGroup(testCtx, "simple_tests", "Blitting image simple tests"));
3542 de::MovePtr<tcu::TestCaseGroup> blitImgAllFormatsTests (new tcu::TestCaseGroup(testCtx, "all_formats", "Blitting image with all compatible formats"));
3544 de::MovePtr<tcu::TestCaseGroup> resolveImageTests (new tcu::TestCaseGroup(testCtx, "resolve_image", "Resolve image"));
3546 const deInt32 defaultSize = 64;
3547 const deInt32 defaultHalfSize = defaultSize / 2;
3548 const deInt32 defaultFourthSize = defaultSize / 4;
3549 const VkExtent3D defaultExtent = {defaultSize, defaultSize, 1};
3550 const VkExtent3D defaultHalfExtent = {defaultHalfSize, defaultHalfSize, 1};
3552 const VkImageSubresourceLayers defaultSourceLayer =
3554 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
3555 0u, // uint32_t mipLevel;
3556 0u, // uint32_t baseArrayLayer;
3557 1u, // uint32_t layerCount;
3560 const VkFormat depthAndStencilFormats[] =
3562 VK_FORMAT_D16_UNORM,
3563 VK_FORMAT_X8_D24_UNORM_PACK32,
3564 VK_FORMAT_D32_SFLOAT,
3566 VK_FORMAT_D16_UNORM_S8_UINT,
3567 VK_FORMAT_D24_UNORM_S8_UINT,
3568 VK_FORMAT_D32_SFLOAT_S8_UINT,
3571 // Copy image to image testcases.
3574 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3575 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3576 params.src.image.extent = defaultExtent;
3577 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3578 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3579 params.dst.image.extent = defaultExtent;
3582 const VkImageCopy testCopy =
3584 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3585 {0, 0, 0}, // VkOffset3D srcOffset;
3586 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3587 {0, 0, 0}, // VkOffset3D dstOffset;
3588 defaultExtent, // VkExtent3D extent;
3591 CopyRegion imageCopy;
3592 imageCopy.imageCopy = testCopy;
3594 params.regions.push_back(imageCopy);
3597 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image", "Whole image", params));
3602 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3603 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3604 params.src.image.extent = defaultExtent;
3605 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3606 params.dst.image.format = VK_FORMAT_R32_UINT;
3607 params.dst.image.extent = defaultExtent;
3610 const VkImageCopy testCopy =
3612 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3613 {0, 0, 0}, // VkOffset3D srcOffset;
3614 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3615 {0, 0, 0}, // VkOffset3D dstOffset;
3616 defaultExtent, // VkExtent3D extent;
3619 CopyRegion imageCopy;
3620 imageCopy.imageCopy = testCopy;
3622 params.regions.push_back(imageCopy);
3625 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "whole_image_diff_fromat", "Whole image with different format", params));
3630 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3631 params.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
3632 params.src.image.extent = defaultExtent;
3633 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3634 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3635 params.dst.image.extent = defaultExtent;
3638 const VkImageCopy testCopy =
3640 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3641 {0, 0, 0}, // VkOffset3D srcOffset;
3642 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3643 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3644 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3647 CopyRegion imageCopy;
3648 imageCopy.imageCopy = testCopy;
3650 params.regions.push_back(imageCopy);
3653 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "partial_image", "Partial image", params));
3658 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3659 params.src.image.format = VK_FORMAT_D32_SFLOAT;
3660 params.src.image.extent = defaultExtent;
3661 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3662 params.dst.image.format = VK_FORMAT_D32_SFLOAT;
3663 params.dst.image.extent = defaultExtent;
3666 const VkImageSubresourceLayers sourceLayer =
3668 VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
3669 0u, // uint32_t mipLevel;
3670 0u, // uint32_t baseArrayLayer;
3671 1u // uint32_t layerCount;
3673 const VkImageCopy testCopy =
3675 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3676 {0, 0, 0}, // VkOffset3D srcOffset;
3677 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3678 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3679 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3682 CopyRegion imageCopy;
3683 imageCopy.imageCopy = testCopy;
3685 params.regions.push_back(imageCopy);
3688 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "depth", "With depth", params));
3693 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3694 params.src.image.format = VK_FORMAT_S8_UINT;
3695 params.src.image.extent = defaultExtent;
3696 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3697 params.dst.image.format = VK_FORMAT_S8_UINT;
3698 params.dst.image.extent = defaultExtent;
3701 const VkImageSubresourceLayers sourceLayer =
3703 VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
3704 0u, // uint32_t mipLevel;
3705 0u, // uint32_t baseArrayLayer;
3706 1u // uint32_t layerCount;
3708 const VkImageCopy testCopy =
3710 sourceLayer, // VkImageSubresourceLayers srcSubresource;
3711 {0, 0, 0}, // VkOffset3D srcOffset;
3712 sourceLayer, // VkImageSubresourceLayers dstSubresource;
3713 {defaultFourthSize, defaultFourthSize / 2, 0}, // VkOffset3D dstOffset;
3714 {defaultFourthSize / 2, defaultFourthSize / 2, 1}, // VkExtent3D extent;
3717 CopyRegion imageCopy;
3718 imageCopy.imageCopy = testCopy;
3720 params.regions.push_back(imageCopy);
3723 imgToImgSimpleTests->addChild(new CopyImageToImageTestCase(testCtx, "stencil", "With stencil", params));
3727 // Test Color formats.
3730 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3731 params.src.image.extent = defaultExtent;
3732 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3733 params.dst.image.extent = defaultExtent;
3735 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3737 const VkImageCopy testCopy =
3739 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
3740 {0, 0, 0}, // VkOffset3D srcOffset;
3741 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
3742 {i, defaultSize - i - defaultFourthSize, 0}, // VkOffset3D dstOffset;
3743 {defaultFourthSize, defaultFourthSize, 1}, // VkExtent3D extent;
3746 CopyRegion imageCopy;
3747 imageCopy.imageCopy = testCopy;
3749 params.regions.push_back(imageCopy);
3752 addCopyImageTestsAllFormats(imgToImgAllFormatsTests.get(), testCtx, params);
3755 // Test Depth and Stencil formats.
3757 const std::string description ("Copy image to image with depth/stencil formats ");
3758 const std::string testName ("depth_stencil");
3760 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
3764 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3765 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3766 params.src.image.extent = defaultExtent;
3767 params.dst.image.extent = defaultExtent;
3768 params.src.image.format = depthAndStencilFormats[compatibleFormatsIndex];
3769 params.dst.image.format = params.src.image.format;
3770 std::ostringstream oss;
3771 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
3773 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
3774 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
3776 for (deInt32 i = 0; i < defaultSize; i += defaultFourthSize)
3778 CopyRegion copyRegion;
3779 const VkOffset3D srcOffset = {0, 0, 0};
3780 const VkOffset3D dstOffset = {i, defaultSize - i - defaultFourthSize, 0};
3781 const VkExtent3D extent = {defaultFourthSize, defaultFourthSize, 1};
3783 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
3785 const VkImageCopy testCopy =
3787 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
3788 srcOffset, // VkOffset3D srcOffset;
3789 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
3790 dstOffset, // VkOffset3D dstOffset;
3791 extent, // VkExtent3D extent;
3794 copyRegion.imageCopy = testCopy;
3795 params.regions.push_back(copyRegion);
3797 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
3799 const VkImageCopy testCopy =
3801 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
3802 srcOffset, // VkOffset3D srcOffset;
3803 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
3804 dstOffset, // VkOffset3D dstOffset;
3805 extent, // VkExtent3D extent;
3808 copyRegion.imageCopy = testCopy;
3809 params.regions.push_back(copyRegion);
3813 imgToImgAllFormatsTests->addChild(new CopyImageToImageTestCase(testCtx, oss.str(), description, params));
3817 imageToImageTests->addChild(imgToImgSimpleTests.release());
3818 imageToImageTests->addChild(imgToImgAllFormatsTests.release());
3820 // Copy image to buffer testcases.
3823 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3824 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3825 params.src.image.extent = defaultExtent;
3826 params.dst.buffer.size = defaultSize * defaultSize;
3828 const VkBufferImageCopy bufferImageCopy =
3830 0u, // VkDeviceSize bufferOffset;
3831 0u, // uint32_t bufferRowLength;
3832 0u, // uint32_t bufferImageHeight;
3833 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3834 {0, 0, 0}, // VkOffset3D imageOffset;
3835 defaultExtent // VkExtent3D imageExtent;
3837 CopyRegion copyRegion;
3838 copyRegion.bufferImageCopy = bufferImageCopy;
3840 params.regions.push_back(copyRegion);
3842 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "whole", "Copy from image to buffer", params));
3847 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3848 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3849 params.src.image.extent = defaultExtent;
3850 params.dst.buffer.size = defaultSize * defaultSize;
3852 const VkBufferImageCopy bufferImageCopy =
3854 defaultSize * defaultHalfSize, // VkDeviceSize bufferOffset;
3855 0u, // uint32_t bufferRowLength;
3856 0u, // uint32_t bufferImageHeight;
3857 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3858 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3859 defaultHalfExtent // VkExtent3D imageExtent;
3861 CopyRegion copyRegion;
3862 copyRegion.bufferImageCopy = bufferImageCopy;
3864 params.regions.push_back(copyRegion);
3866 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "buffer_offset", "Copy from image to buffer with buffer offset", params));
3871 params.src.image.imageType = VK_IMAGE_TYPE_2D;
3872 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3873 params.src.image.extent = defaultExtent;
3874 params.dst.buffer.size = defaultSize * defaultSize;
3876 const int pixelSize = tcu::getPixelSize(mapVkFormat(params.src.image.format));
3877 const VkDeviceSize bufferSize = pixelSize * params.dst.buffer.size;
3878 const VkDeviceSize offsetSize = pixelSize * defaultFourthSize * defaultFourthSize;
3879 deUint32 divisor = 1;
3880 for (VkDeviceSize offset = 0; offset < bufferSize - offsetSize; offset += offsetSize, ++divisor)
3882 const deUint32 bufferRowLength = defaultFourthSize;
3883 const deUint32 bufferImageHeight = defaultFourthSize;
3884 const VkExtent3D imageExtent = {defaultFourthSize / divisor, defaultFourthSize, 1};
3885 DE_ASSERT(!bufferRowLength || bufferRowLength >= imageExtent.width);
3886 DE_ASSERT(!bufferImageHeight || bufferImageHeight >= imageExtent.height);
3887 DE_ASSERT(imageExtent.width * imageExtent.height *imageExtent.depth <= offsetSize);
3890 const VkBufferImageCopy bufferImageCopy =
3892 offset, // VkDeviceSize bufferOffset;
3893 bufferRowLength, // uint32_t bufferRowLength;
3894 bufferImageHeight, // uint32_t bufferImageHeight;
3895 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3896 {0, 0, 0}, // VkOffset3D imageOffset;
3897 imageExtent // VkExtent3D imageExtent;
3899 region.bufferImageCopy = bufferImageCopy;
3900 params.regions.push_back(region);
3903 imageToBufferTests->addChild(new CopyImageToBufferTestCase(testCtx, "regions", "Copy from image to buffer with multiple regions", params));
3906 // Copy buffer to image testcases.
3909 params.src.buffer.size = defaultSize * defaultSize;
3910 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3911 params.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
3912 params.dst.image.extent = defaultExtent;
3914 const VkBufferImageCopy bufferImageCopy =
3916 0u, // VkDeviceSize bufferOffset;
3917 0u, // uint32_t bufferRowLength;
3918 0u, // uint32_t bufferImageHeight;
3919 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3920 {0, 0, 0}, // VkOffset3D imageOffset;
3921 defaultExtent // VkExtent3D imageExtent;
3923 CopyRegion copyRegion;
3924 copyRegion.bufferImageCopy = bufferImageCopy;
3926 params.regions.push_back(copyRegion);
3928 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "whole", "Copy from buffer to image", params));
3933 params.src.buffer.size = defaultSize * defaultSize;
3934 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3935 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3936 params.dst.image.extent = defaultExtent;
3939 deUint32 divisor = 1;
3940 for (int offset = 0; (offset + defaultFourthSize / divisor < defaultSize) && (defaultFourthSize > divisor); offset += defaultFourthSize / divisor++)
3942 const VkBufferImageCopy bufferImageCopy =
3944 0u, // VkDeviceSize bufferOffset;
3945 0u, // uint32_t bufferRowLength;
3946 0u, // uint32_t bufferImageHeight;
3947 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3948 {offset, defaultHalfSize, 0}, // VkOffset3D imageOffset;
3949 {defaultFourthSize / divisor, defaultFourthSize / divisor, 1} // VkExtent3D imageExtent;
3951 region.bufferImageCopy = bufferImageCopy;
3952 params.regions.push_back(region);
3955 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "regions", "Copy from buffer to image with multiple regions", params));
3960 params.src.buffer.size = defaultSize * defaultSize;
3961 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
3962 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
3963 params.dst.image.extent = defaultExtent;
3965 const VkBufferImageCopy bufferImageCopy =
3967 defaultFourthSize, // VkDeviceSize bufferOffset;
3968 defaultHalfSize + defaultFourthSize, // uint32_t bufferRowLength;
3969 defaultHalfSize + defaultFourthSize, // uint32_t bufferImageHeight;
3970 defaultSourceLayer, // VkImageSubresourceLayers imageSubresource;
3971 {defaultFourthSize, defaultFourthSize, 0}, // VkOffset3D imageOffset;
3972 defaultHalfExtent // VkExtent3D imageExtent;
3974 CopyRegion copyRegion;
3975 copyRegion.bufferImageCopy = bufferImageCopy;
3977 params.regions.push_back(copyRegion);
3979 bufferToImageTests->addChild(new CopyBufferToImageTestCase(testCtx, "buffer_offset", "Copy from buffer to image with buffer offset", params));
3982 // Copy buffer to buffer testcases.
3985 params.src.buffer.size = defaultSize;
3986 params.dst.buffer.size = defaultSize;
3988 const VkBufferCopy bufferCopy =
3990 0u, // VkDeviceSize srcOffset;
3991 0u, // VkDeviceSize dstOffset;
3992 defaultSize, // VkDeviceSize size;
3995 CopyRegion copyRegion;
3996 copyRegion.bufferCopy = bufferCopy;
3997 params.regions.push_back(copyRegion);
3999 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "whole", "Whole buffer", params));
4004 params.src.buffer.size = defaultFourthSize;
4005 params.dst.buffer.size = defaultFourthSize;
4007 const VkBufferCopy bufferCopy =
4009 12u, // VkDeviceSize srcOffset;
4010 4u, // VkDeviceSize dstOffset;
4011 1u, // VkDeviceSize size;
4014 CopyRegion copyRegion;
4015 copyRegion.bufferCopy = bufferCopy;
4016 params.regions.push_back(copyRegion);
4018 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "partial", "Partial", params));
4022 const deUint32 size = 16;
4024 params.src.buffer.size = size;
4025 params.dst.buffer.size = size * (size + 1);
4027 // Copy region with size 1..size
4028 for (unsigned int i = 1; i <= size; i++)
4030 const VkBufferCopy bufferCopy =
4032 0, // VkDeviceSize srcOffset;
4033 i * size, // VkDeviceSize dstOffset;
4034 i, // VkDeviceSize size;
4037 CopyRegion copyRegion;
4038 copyRegion.bufferCopy = bufferCopy;
4039 params.regions.push_back(copyRegion);
4042 bufferToBufferTests->addChild(new BufferToBufferTestCase(testCtx, "regions", "Multiple regions", params));
4045 // Blitting testcases.
4047 const std::string description ("Blit without scaling (whole)");
4048 const std::string testName ("whole");
4051 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4052 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4053 params.src.image.extent = defaultExtent;
4054 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4055 params.dst.image.extent = defaultExtent;
4058 const VkImageBlit imageBlit =
4060 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4063 {defaultSize, defaultSize, 1}
4064 }, // VkOffset3D srcOffsets[2];
4066 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4069 {defaultSize, defaultSize, 1}
4070 } // VkOffset3D dstOffset[2];
4074 region.imageBlit = imageBlit;
4075 params.regions.push_back(region);
4078 // Filter is VK_FILTER_NEAREST.
4080 params.filter = VK_FILTER_NEAREST;
4082 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4083 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4085 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4086 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4087 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4089 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4090 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4091 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4094 // Filter is VK_FILTER_LINEAR.
4096 params.filter = VK_FILTER_LINEAR;
4098 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4099 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4101 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4102 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4103 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4105 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4106 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4107 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4112 const std::string description ("Flipping x and y coordinates (whole)");
4113 const std::string testName ("mirror_xy");
4116 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4117 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4118 params.src.image.extent = defaultExtent;
4119 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4120 params.dst.image.extent = defaultExtent;
4123 const VkImageBlit imageBlit =
4125 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4128 {defaultSize, defaultSize, 1}
4129 }, // VkOffset3D srcOffsets[2];
4131 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4133 {defaultSize, defaultSize, 0},
4135 } // VkOffset3D dstOffset[2];
4139 region.imageBlit = imageBlit;
4140 params.regions.push_back(region);
4143 // Filter is VK_FILTER_NEAREST.
4145 params.filter = VK_FILTER_NEAREST;
4147 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4148 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4150 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4151 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4152 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4154 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4155 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4156 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4159 // Filter is VK_FILTER_LINEAR.
4161 params.filter = VK_FILTER_LINEAR;
4163 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4164 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4166 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4167 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4168 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4170 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4171 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4172 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4177 const std::string description ("Flipping x coordinates (whole)");
4178 const std::string testName ("mirror_x");
4181 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4182 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4183 params.src.image.extent = defaultExtent;
4184 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4185 params.dst.image.extent = defaultExtent;
4188 const VkImageBlit imageBlit =
4190 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4193 {defaultSize, defaultSize, 1}
4194 }, // VkOffset3D srcOffsets[2];
4196 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4198 {defaultSize, 0, 0},
4200 } // VkOffset3D dstOffset[2];
4204 region.imageBlit = imageBlit;
4205 params.regions.push_back(region);
4208 // Filter is VK_FILTER_NEAREST.
4210 params.filter = VK_FILTER_NEAREST;
4212 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4213 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4215 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4216 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4217 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4219 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4220 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4221 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4224 // Filter is VK_FILTER_LINEAR.
4226 params.filter = VK_FILTER_LINEAR;
4228 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4229 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4231 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4232 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4233 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4235 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4236 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4237 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4242 const std::string description ("Flipping Y coordinates (whole)");
4243 const std::string testName ("mirror_y");
4246 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4247 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4248 params.src.image.extent = defaultExtent;
4249 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4250 params.dst.image.extent = defaultExtent;
4253 const VkImageBlit imageBlit =
4255 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4258 {defaultSize, defaultSize, 1}
4259 }, // VkOffset3D srcOffsets[2];
4261 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4263 {0, defaultSize, 0},
4265 } // VkOffset3D dstOffset[2];
4269 region.imageBlit = imageBlit;
4270 params.regions.push_back(region);
4273 // Filter is VK_FILTER_NEAREST.
4275 params.filter = VK_FILTER_NEAREST;
4277 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4278 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4280 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4281 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4282 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4284 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4285 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4286 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4289 // Filter is VK_FILTER_LINEAR.
4291 params.filter = VK_FILTER_LINEAR;
4293 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4294 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4296 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4297 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4298 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4300 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4301 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4302 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4307 const std::string description ("Mirroring subregions in image (no flip ,y flip ,x flip, xy flip)");
4308 const std::string testName ("mirror_subregions");
4311 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4312 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4313 params.src.image.extent = defaultExtent;
4314 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4315 params.dst.image.extent = defaultExtent;
4319 const VkImageBlit imageBlit =
4321 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4324 {defaultHalfSize, defaultHalfSize, 1}
4325 }, // VkOffset3D srcOffsets[2];
4327 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4330 {defaultHalfSize, defaultHalfSize, 1}
4331 } // VkOffset3D dstOffset[2];
4335 region.imageBlit = imageBlit;
4336 params.regions.push_back(region);
4339 // Flipping y coordinates.
4341 const VkImageBlit imageBlit =
4343 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4345 {defaultHalfSize, 0, 0},
4346 {defaultSize, defaultHalfSize, 1}
4347 }, // VkOffset3D srcOffsets[2];
4349 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4351 {defaultHalfSize, defaultHalfSize, 0},
4353 } // VkOffset3D dstOffset[2];
4357 region.imageBlit = imageBlit;
4358 params.regions.push_back(region);
4361 // Flipping x coordinates.
4363 const VkImageBlit imageBlit =
4365 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4367 {0, defaultHalfSize, 0},
4368 {defaultHalfSize, defaultSize, 1}
4369 }, // VkOffset3D srcOffsets[2];
4371 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4373 {defaultHalfSize, defaultHalfSize, 0},
4375 } // VkOffset3D dstOffset[2];
4379 region.imageBlit = imageBlit;
4380 params.regions.push_back(region);
4383 // Flipping x and y coordinates.
4385 const VkImageBlit imageBlit =
4387 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4389 {defaultHalfSize, defaultHalfSize, 0},
4390 {defaultSize, defaultSize, 1}
4391 }, // VkOffset3D srcOffsets[2];
4393 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4395 {defaultSize, defaultSize, 0},
4396 {defaultHalfSize, defaultHalfSize, 1}
4397 } // VkOffset3D dstOffset[2];
4401 region.imageBlit = imageBlit;
4402 params.regions.push_back(region);
4405 // Filter is VK_FILTER_NEAREST.
4407 params.filter = VK_FILTER_NEAREST;
4409 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4410 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4412 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4413 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4414 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4416 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4417 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4418 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4421 // Filter is VK_FILTER_LINEAR.
4423 params.filter = VK_FILTER_LINEAR;
4425 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4426 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4428 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4429 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4430 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4432 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4433 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4434 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4439 const std::string description ("Blit with scaling (whole, src extent bigger)");
4440 const std::string testName ("scaling_whole1");
4443 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4444 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4445 params.src.image.extent = defaultExtent;
4446 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4447 params.dst.image.extent = defaultHalfExtent;
4450 const VkImageBlit imageBlit =
4452 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4455 {defaultSize, defaultSize, 1}
4456 }, // VkOffset3D srcOffsets[2];
4458 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4461 {defaultHalfSize, defaultHalfSize, 1}
4462 } // VkOffset3D dstOffset[2];
4466 region.imageBlit = imageBlit;
4467 params.regions.push_back(region);
4470 // Filter is VK_FILTER_NEAREST.
4472 params.filter = VK_FILTER_NEAREST;
4474 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4475 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4477 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4478 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4479 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4481 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4482 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4483 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4486 // Filter is VK_FILTER_LINEAR.
4488 params.filter = VK_FILTER_LINEAR;
4490 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4491 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4493 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4494 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4495 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4497 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4498 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4499 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4504 const std::string description ("Blit with scaling (whole, dst extent bigger)");
4505 const std::string testName ("scaling_whole2");
4508 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4509 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4510 params.src.image.extent = defaultHalfExtent;
4511 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4512 params.dst.image.extent = defaultExtent;
4515 const VkImageBlit imageBlit =
4517 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4520 {defaultHalfSize, defaultHalfSize, 1}
4521 }, // VkOffset3D srcOffsets[2];
4523 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4526 {defaultSize, defaultSize, 1}
4527 } // VkOffset3D dstOffset[2];
4531 region.imageBlit = imageBlit;
4532 params.regions.push_back(region);
4535 // Filter is VK_FILTER_NEAREST.
4537 params.filter = VK_FILTER_NEAREST;
4539 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4540 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4542 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4543 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4544 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4546 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4547 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4548 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4551 // Filter is VK_FILTER_LINEAR.
4553 params.filter = VK_FILTER_LINEAR;
4555 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4556 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4558 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4559 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4560 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4562 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4563 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4564 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4569 const std::string description ("Blit with scaling and offset (whole, dst extent bigger)");
4570 const std::string testName ("scaling_and_offset");
4573 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4574 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4575 params.src.image.extent = defaultExtent;
4576 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4577 params.dst.image.extent = defaultExtent;
4580 const VkImageBlit imageBlit =
4582 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4584 {defaultFourthSize, defaultFourthSize, 0},
4585 {defaultFourthSize*3, defaultFourthSize*3, 1}
4586 }, // VkOffset3D srcOffsets[2];
4588 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4591 {defaultSize, defaultSize, 1}
4592 } // VkOffset3D dstOffset[2];
4596 region.imageBlit = imageBlit;
4597 params.regions.push_back(region);
4600 // Filter is VK_FILTER_NEAREST.
4602 params.filter = VK_FILTER_NEAREST;
4604 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4605 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4607 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4608 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4609 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4611 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4612 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4613 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4616 // Filter is VK_FILTER_LINEAR.
4618 params.filter = VK_FILTER_LINEAR;
4620 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4621 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4623 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4624 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4625 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4627 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4628 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4629 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4634 const std::string description ("Blit without scaling (partial)");
4635 const std::string testName ("without_scaling_partial");
4638 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4639 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4640 params.src.image.extent = defaultExtent;
4641 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4642 params.dst.image.extent = defaultExtent;
4646 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4648 const VkImageBlit imageBlit =
4650 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4652 {defaultSize - defaultFourthSize - i, defaultSize - defaultFourthSize - i, 0},
4653 {defaultSize - i, defaultSize - i, 1}
4654 }, // VkOffset3D srcOffsets[2];
4656 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4659 {i + defaultFourthSize, i + defaultFourthSize, 1}
4660 } // VkOffset3D dstOffset[2];
4662 region.imageBlit = imageBlit;
4663 params.regions.push_back(region);
4667 // Filter is VK_FILTER_NEAREST.
4669 params.filter = VK_FILTER_NEAREST;
4671 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4672 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_nearest", description, params));
4675 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4676 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)");
4677 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToR32, params));
4679 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4680 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)");
4681 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_nearest", descriptionOfRGBAToBGRA, params));
4684 // Filter is VK_FILTER_LINEAR.
4686 params.filter = VK_FILTER_LINEAR;
4688 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4689 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_linear", description + " (VK_FILTER_LINEAR)", params));
4691 params.dst.image.format = VK_FORMAT_R32_SFLOAT;
4692 const std::string descriptionOfRGBAToR32 (description + " and different formats (R8G8B8A8 -> R32)" + " (VK_FILTER_LINEAR)");
4693 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToR32, params));
4695 params.dst.image.format = VK_FORMAT_B8G8R8A8_UNORM;
4696 const std::string descriptionOfRGBAToBGRA (description + " and different formats (R8G8B8A8 -> B8G8R8A8)" + " (VK_FILTER_LINEAR)");
4697 blitImgSimpleTests->addChild(new BlittingTestCase(testCtx, testName + "_" + getFormatCaseName(params.dst.image.format) + "_linear", descriptionOfRGBAToBGRA, params));
4702 const std::string description ("Blit with scaling (partial)");
4703 const std::string testName ("scaling_partial");
4705 // Test Color formats.
4708 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4709 params.src.image.extent = defaultExtent;
4710 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4711 params.dst.image.extent = defaultExtent;
4714 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4716 const VkImageBlit imageBlit =
4718 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4721 {defaultSize, defaultSize, 1}
4722 }, // VkOffset3D srcOffsets[2];
4724 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4727 {i + defaultFourthSize / j, defaultFourthSize / j, 1}
4728 } // VkOffset3D dstOffset[2];
4730 region.imageBlit = imageBlit;
4731 params.regions.push_back(region);
4733 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4735 const VkImageBlit imageBlit =
4737 defaultSourceLayer, // VkImageSubresourceLayers srcSubresource;
4740 {i + defaultFourthSize, i + defaultFourthSize, 1}
4741 }, // VkOffset3D srcOffsets[2];
4743 defaultSourceLayer, // VkImageSubresourceLayers dstSubresource;
4745 {i, defaultSize / 2, 0},
4746 {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1}
4747 } // VkOffset3D dstOffset[2];
4749 region.imageBlit = imageBlit;
4750 params.regions.push_back(region);
4753 addBlittingTestsAllFormats(blitImgAllFormatsTests.get(), testCtx, params);
4756 // Test Depth and Stencil formats.
4758 for (size_t compatibleFormatsIndex = 0; compatibleFormatsIndex < DE_LENGTH_OF_ARRAY(depthAndStencilFormats); ++compatibleFormatsIndex)
4762 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4763 params.src.image.extent = defaultExtent;
4764 params.dst.image.extent = defaultExtent;
4765 params.src.image.format = depthAndStencilFormats[compatibleFormatsIndex];
4766 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4767 params.dst.image.format = params.src.image.format;
4768 std::ostringstream oss;
4769 oss << testName << "_" << getFormatCaseName(params.src.image.format) << "_" << getFormatCaseName(params.dst.image.format);
4771 const VkImageSubresourceLayers defaultDepthSourceLayer = { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
4772 const VkImageSubresourceLayers defaultStencilSourceLayer = { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
4775 for (int i = 0, j = 1; (i + defaultFourthSize / j < defaultSize) && (defaultFourthSize > j); i += defaultFourthSize / j++)
4777 const VkOffset3D srcOffset0 = {0, 0, 0};
4778 const VkOffset3D srcOffset1 = {defaultSize, defaultSize, 1};
4779 const VkOffset3D dstOffset0 = {i, 0, 0};
4780 const VkOffset3D dstOffset1 = {i + defaultFourthSize / j, defaultFourthSize / j, 1};
4782 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4784 const VkImageBlit imageBlit =
4786 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4787 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4788 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4789 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4791 region.imageBlit = imageBlit;
4792 params.regions.push_back(region);
4794 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4796 const VkImageBlit imageBlit =
4798 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4799 { srcOffset0 , srcOffset1 }, // VkOffset3D srcOffsets[2];
4800 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4801 { dstOffset0 , dstOffset1 }, // VkOffset3D dstOffset[2];
4803 region.imageBlit = imageBlit;
4804 params.regions.push_back(region);
4807 for (int i = 0; i < defaultSize; i += defaultFourthSize)
4809 const VkOffset3D srcOffset0 = {i, i, 0};
4810 const VkOffset3D srcOffset1 = {i + defaultFourthSize, i + defaultFourthSize, 1};
4811 const VkOffset3D dstOffset0 = {i, defaultSize / 2, 0};
4812 const VkOffset3D dstOffset1 = {i + defaultFourthSize, defaultSize / 2 + defaultFourthSize, 1};
4814 if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
4816 const VkImageBlit imageBlit =
4818 defaultDepthSourceLayer, // VkImageSubresourceLayers srcSubresource;
4819 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4820 defaultDepthSourceLayer, // VkImageSubresourceLayers dstSubresource;
4821 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4823 region.imageBlit = imageBlit;
4824 params.regions.push_back(region);
4826 if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
4828 const VkImageBlit imageBlit =
4830 defaultStencilSourceLayer, // VkImageSubresourceLayers srcSubresource;
4831 { srcOffset0, srcOffset1 }, // VkOffset3D srcOffsets[2];
4832 defaultStencilSourceLayer, // VkImageSubresourceLayers dstSubresource;
4833 { dstOffset0, dstOffset1 } // VkOffset3D dstOffset[2];
4835 region.imageBlit = imageBlit;
4836 params.regions.push_back(region);
4840 params.filter = VK_FILTER_NEAREST;
4841 blitImgAllFormatsTests->addChild(new BlittingTestCase(testCtx, oss.str() + "_nearest", description, params));
4845 blittingImageTests->addChild(blitImgSimpleTests.release());
4846 blittingImageTests->addChild(blitImgAllFormatsTests.release());
4848 // Resolve image to image testcases.
4849 const VkSampleCountFlagBits samples[] =
4851 VK_SAMPLE_COUNT_2_BIT,
4852 VK_SAMPLE_COUNT_4_BIT,
4853 VK_SAMPLE_COUNT_8_BIT,
4854 VK_SAMPLE_COUNT_16_BIT,
4855 VK_SAMPLE_COUNT_32_BIT,
4856 VK_SAMPLE_COUNT_64_BIT
4858 const VkExtent3D resolveExtent = {256u, 256u, 1};
4861 const std::string description ("Resolve from image to image");
4862 const std::string testName ("whole");
4865 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4866 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4867 params.src.image.extent = resolveExtent;
4868 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4869 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4870 params.dst.image.extent = resolveExtent;
4873 const VkImageSubresourceLayers sourceLayer =
4875 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4876 0u, // uint32_t mipLevel;
4877 0u, // uint32_t baseArrayLayer;
4878 1u // uint32_t layerCount;
4880 const VkImageResolve testResolve =
4882 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4883 {0, 0, 0}, // VkOffset3D srcOffset;
4884 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4885 {0, 0, 0}, // VkOffset3D dstOffset;
4886 resolveExtent, // VkExtent3D extent;
4889 CopyRegion imageResolve;
4890 imageResolve.imageResolve = testResolve;
4891 params.regions.push_back(imageResolve);
4894 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4896 params.samples = samples[samplesIndex];
4897 std::ostringstream caseName;
4898 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4899 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4904 const std::string description ("Resolve from image to image");
4905 const std::string testName ("partial");
4908 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4909 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4910 params.src.image.extent = resolveExtent;
4911 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4912 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4913 params.dst.image.extent = resolveExtent;
4916 const VkImageSubresourceLayers sourceLayer =
4918 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4919 0u, // uint32_t mipLevel;
4920 0u, // uint32_t baseArrayLayer;
4921 1u // uint32_t layerCount;
4923 const VkImageResolve testResolve =
4925 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4926 {0, 0, 0}, // VkOffset3D srcOffset;
4927 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4928 {64u, 64u, 0}, // VkOffset3D dstOffset;
4929 {128u, 128u, 1u}, // VkExtent3D extent;
4932 CopyRegion imageResolve;
4933 imageResolve.imageResolve = testResolve;
4934 params.regions.push_back(imageResolve);
4937 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4939 params.samples = samples[samplesIndex];
4940 std::ostringstream caseName;
4941 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4942 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4947 const std::string description ("Resolve from image to image");
4948 const std::string testName ("with_regions");
4951 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4952 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4953 params.src.image.extent = resolveExtent;
4954 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
4955 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
4956 params.dst.image.extent = resolveExtent;
4959 const VkImageSubresourceLayers sourceLayer =
4961 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
4962 0u, // uint32_t mipLevel;
4963 0u, // uint32_t baseArrayLayer;
4964 1u // uint32_t layerCount;
4967 for (int i = 0; i < 256; i += 64)
4969 const VkImageResolve testResolve =
4971 sourceLayer, // VkImageSubresourceLayers srcSubresource;
4972 {i, i, 0}, // VkOffset3D srcOffset;
4973 sourceLayer, // VkImageSubresourceLayers dstSubresource;
4974 {i, 0, 0}, // VkOffset3D dstOffset;
4975 {64u, 64u, 1u}, // VkExtent3D extent;
4978 CopyRegion imageResolve;
4979 imageResolve.imageResolve = testResolve;
4980 params.regions.push_back(imageResolve);
4984 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
4986 params.samples = samples[samplesIndex];
4987 std::ostringstream caseName;
4988 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
4989 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params));
4994 const std::string description ("Resolve from image to image");
4995 const std::string testName ("whole_copy_before_resolving");
4998 params.src.image.imageType = VK_IMAGE_TYPE_2D;
4999 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5000 params.src.image.extent = defaultExtent;
5001 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
5002 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5003 params.dst.image.extent = defaultExtent;
5006 const VkImageSubresourceLayers sourceLayer =
5008 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5009 0u, // uint32_t mipLevel;
5010 0u, // uint32_t baseArrayLayer;
5011 1u // uint32_t layerCount;
5014 const VkImageResolve testResolve =
5016 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5017 {0, 0, 0}, // VkOffset3D srcOffset;
5018 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5019 {0, 0, 0}, // VkOffset3D dstOffset;
5020 defaultExtent, // VkExtent3D extent;
5023 CopyRegion imageResolve;
5024 imageResolve.imageResolve = testResolve;
5025 params.regions.push_back(imageResolve);
5028 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
5030 params.samples = samples[samplesIndex];
5031 std::ostringstream caseName;
5032 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
5033 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_MS_IMAGE));
5038 const std::string description ("Resolve from image to image");
5039 const std::string testName ("whole_array_image");
5042 params.src.image.imageType = VK_IMAGE_TYPE_2D;
5043 params.src.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5044 params.src.image.extent = defaultExtent;
5045 params.dst.image.imageType = VK_IMAGE_TYPE_2D;
5046 params.dst.image.format = VK_FORMAT_R8G8B8A8_UNORM;
5047 params.dst.image.extent = defaultExtent;
5048 params.dst.image.extent.depth = 5u;
5050 for (deUint32 layerNdx=0; layerNdx < params.dst.image.extent.depth; ++layerNdx)
5052 const VkImageSubresourceLayers sourceLayer =
5054 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5055 0u, // uint32_t mipLevel;
5056 layerNdx, // uint32_t baseArrayLayer;
5057 1u // uint32_t layerCount;
5060 const VkImageResolve testResolve =
5062 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5063 {0, 0, 0}, // VkOffset3D srcOffset;
5064 sourceLayer, // VkImageSubresourceLayers dstSubresource;
5065 {0, 0, 0}, // VkOffset3D dstOffset;
5066 defaultExtent, // VkExtent3D extent;
5069 CopyRegion imageResolve;
5070 imageResolve.imageResolve = testResolve;
5071 params.regions.push_back(imageResolve);
5074 for (int samplesIndex = 0; samplesIndex < DE_LENGTH_OF_ARRAY(samples); ++samplesIndex)
5076 params.samples = samples[samplesIndex];
5077 std::ostringstream caseName;
5078 caseName << testName << "_" << getSampleCountCaseName(samples[samplesIndex]);
5079 resolveImageTests->addChild(new ResolveImageToImageTestCase(testCtx, caseName.str(), description, params, COPY_MS_IMAGE_TO_ARRAY_MS_IMAGE));
5084 TestParams params3DTo2D;
5085 const deUint32 slicesLayers = 16u;
5086 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5087 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5088 params3DTo2D.src.image.extent = defaultHalfExtent;
5089 params3DTo2D.src.image.extent.depth = slicesLayers;
5090 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5091 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5092 params3DTo2D.dst.image.extent = defaultHalfExtent;
5093 params3DTo2D.dst.image.extent.depth = slicesLayers;
5095 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5097 const VkImageSubresourceLayers sourceLayer =
5099 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5100 0u, // uint32_t mipLevel;
5101 0u, // uint32_t baseArrayLayer;
5102 1u // uint32_t layerCount;
5105 const VkImageSubresourceLayers destinationLayer =
5107 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5108 0u, // uint32_t mipLevel;
5109 slicesLayersNdx, // uint32_t baseArrayLayer;
5110 1u // uint32_t layerCount;
5113 const VkImageCopy testCopy =
5115 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5116 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
5117 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5118 {0, 0, 0}, // VkOffset3D dstOffset;
5119 defaultHalfExtent, // VkExtent3D extent;
5122 CopyRegion imageCopy;
5123 imageCopy.imageCopy = testCopy;
5125 params3DTo2D.regions.push_back(imageCopy);
5127 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_by_slices", "copy 2d layers to 3d slices one by one", params3DTo2D));
5131 TestParams params2DTo3D;
5132 const deUint32 slicesLayers = 16u;
5133 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5134 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5135 params2DTo3D.src.image.extent = defaultHalfExtent;
5136 params2DTo3D.src.image.extent.depth = slicesLayers;
5137 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5138 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5139 params2DTo3D.dst.image.extent = defaultHalfExtent;
5140 params2DTo3D.dst.image.extent.depth = slicesLayers;
5142 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5144 const VkImageSubresourceLayers sourceLayer =
5146 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5147 0u, // uint32_t mipLevel;
5148 slicesLayersNdx, // uint32_t baseArrayLayer;
5149 1u // uint32_t layerCount;
5152 const VkImageSubresourceLayers destinationLayer =
5154 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5155 0u, // uint32_t mipLevel;
5156 0u, // uint32_t baseArrayLayer;
5157 1u // uint32_t layerCount;
5160 const VkImageCopy testCopy =
5162 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5163 {0, 0, 0}, // VkOffset3D srcOffset;
5164 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5165 {0, 0, (deInt32)slicesLayersNdx}, // VkOffset3D dstOffset;
5166 defaultHalfExtent, // VkExtent3D extent;
5169 CopyRegion imageCopy;
5170 imageCopy.imageCopy = testCopy;
5172 params2DTo3D.regions.push_back(imageCopy);
5175 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_by_layers", "copy 3d slices to 2d layers one by one", params2DTo3D));
5179 TestParams params3DTo2D;
5180 const deUint32 slicesLayers = 16u;
5181 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5182 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5183 params3DTo2D.src.image.extent = defaultHalfExtent;
5184 params3DTo2D.src.image.extent.depth = slicesLayers;
5185 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5186 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5187 params3DTo2D.dst.image.extent = defaultHalfExtent;
5188 params3DTo2D.dst.image.extent.depth = slicesLayers;
5191 const VkImageSubresourceLayers sourceLayer =
5193 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5194 0u, // uint32_t mipLevel;
5195 0u, // uint32_t baseArrayLayer;
5196 1u // uint32_t layerCount;
5199 const VkImageSubresourceLayers destinationLayer =
5201 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5202 0u, // uint32_t mipLevel;
5203 0, // uint32_t baseArrayLayer;
5204 slicesLayers // uint32_t layerCount;
5207 const VkImageCopy testCopy =
5209 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5210 {0, 0, 0}, // VkOffset3D srcOffset;
5211 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5212 {0, 0, 0}, // VkOffset3D dstOffset;
5213 params3DTo2D.src.image.extent // VkExtent3D extent;
5216 CopyRegion imageCopy;
5217 imageCopy.imageCopy = testCopy;
5219 params3DTo2D.regions.push_back(imageCopy);
5221 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_whole", "copy 3d slices to 2d layers all at once", params3DTo2D));
5225 TestParams params2DTo3D;
5226 const deUint32 slicesLayers = 16u;
5227 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5228 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5229 params2DTo3D.src.image.extent = defaultHalfExtent;
5230 params2DTo3D.src.image.extent.depth = slicesLayers;
5231 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5232 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5233 params2DTo3D.dst.image.extent = defaultHalfExtent;
5234 params2DTo3D.dst.image.extent.depth = slicesLayers;
5237 const VkImageSubresourceLayers sourceLayer =
5239 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5240 0u, // uint32_t mipLevel;
5241 0u, // uint32_t baseArrayLayer;
5242 slicesLayers // uint32_t layerCount;
5245 const VkImageSubresourceLayers destinationLayer =
5247 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5248 0u, // uint32_t mipLevel;
5249 0u, // uint32_t baseArrayLayer;
5250 1u // uint32_t layerCount;
5253 const VkImageCopy testCopy =
5255 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5256 {0, 0, 0}, // VkOffset3D srcOffset;
5257 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5258 {0, 0, 0}, // VkOffset3D dstOffset;
5259 params2DTo3D.dst.image.extent, // VkExtent3D extent;
5262 CopyRegion imageCopy;
5263 imageCopy.imageCopy = testCopy;
5265 params2DTo3D.regions.push_back(imageCopy);
5268 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_whole", "copy 2d layers to 3d slices all at once", params2DTo3D));
5272 TestParams params3DTo2D;
5273 const deUint32 slicesLayers = 16u;
5274 params3DTo2D.src.image.imageType = VK_IMAGE_TYPE_3D;
5275 params3DTo2D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5276 params3DTo2D.src.image.extent = defaultHalfExtent;
5277 params3DTo2D.src.image.extent.depth = slicesLayers;
5278 params3DTo2D.dst.image.imageType = VK_IMAGE_TYPE_2D;
5279 params3DTo2D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5280 params3DTo2D.dst.image.extent = defaultHalfExtent;
5281 params3DTo2D.dst.image.extent.depth = slicesLayers;
5283 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5284 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5286 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5288 const VkImageSubresourceLayers sourceLayer =
5290 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5291 0u, // uint32_t mipLevel;
5292 0u, // uint32_t baseArrayLayer;
5293 1u // uint32_t layerCount;
5296 const VkImageSubresourceLayers destinationLayer =
5298 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5299 0u, // uint32_t mipLevel;
5300 slicesLayersNdx, // uint32_t baseArrayLayer;
5301 1u // uint32_t layerCount;
5305 const VkImageCopy testCopy =
5307 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5308 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)slicesLayersNdx}, // VkOffset3D srcOffset;
5309 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5310 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D dstOffset;
5312 (defaultHalfExtent.width - regionWidth*slicesLayersNdx),
5313 (defaultHalfExtent.height - regionHeight*slicesLayersNdx),
5315 } // VkExtent3D extent;
5318 CopyRegion imageCopy;
5319 imageCopy.imageCopy = testCopy;
5320 params3DTo2D.regions.push_back(imageCopy);
5322 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "3d_to_2d_regions", "copy 3d slices regions to 2d layers", params3DTo2D));
5326 TestParams params2DTo3D;
5327 const deUint32 slicesLayers = 16u;
5328 params2DTo3D.src.image.imageType = VK_IMAGE_TYPE_2D;
5329 params2DTo3D.src.image.format = VK_FORMAT_R8G8B8A8_UINT;
5330 params2DTo3D.src.image.extent = defaultHalfExtent;
5331 params2DTo3D.src.image.extent.depth = slicesLayers;
5332 params2DTo3D.dst.image.imageType = VK_IMAGE_TYPE_3D;
5333 params2DTo3D.dst.image.format = VK_FORMAT_R8G8B8A8_UINT;
5334 params2DTo3D.dst.image.extent = defaultHalfExtent;
5335 params2DTo3D.dst.image.extent.depth = slicesLayers;
5337 const deUint32 regionWidth = defaultHalfExtent.width / slicesLayers -1;
5338 const deUint32 regionHeight = defaultHalfExtent.height / slicesLayers -1 ;
5340 for (deUint32 slicesLayersNdx = 0; slicesLayersNdx < slicesLayers; ++slicesLayersNdx)
5342 const VkImageSubresourceLayers sourceLayer =
5344 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5345 0u, // uint32_t mipLevel;
5346 slicesLayersNdx, // uint32_t baseArrayLayer;
5347 1u // uint32_t layerCount;
5350 const VkImageSubresourceLayers destinationLayer =
5352 VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
5353 0u, // uint32_t mipLevel;
5354 0u, // uint32_t baseArrayLayer;
5355 1u // uint32_t layerCount;
5358 const VkImageCopy testCopy =
5360 sourceLayer, // VkImageSubresourceLayers srcSubresource;
5361 {(deInt32)(regionWidth*slicesLayersNdx), 0, 0}, // VkOffset3D srcOffset;
5362 destinationLayer, // VkImageSubresourceLayers dstSubresource;
5363 {0, (deInt32)(regionHeight*slicesLayersNdx), (deInt32)(slicesLayersNdx)}, // VkOffset3D dstOffset;
5365 defaultHalfExtent.width - regionWidth*slicesLayersNdx,
5366 defaultHalfExtent.height - regionHeight*slicesLayersNdx,
5368 } // VkExtent3D extent;
5371 CopyRegion imageCopy;
5372 imageCopy.imageCopy = testCopy;
5374 params2DTo3D.regions.push_back(imageCopy);
5377 imgToImg3dImagesTests->addChild(new CopyImageToImageTestCase(testCtx, "2d_to_3d_regions", "copy 2d layers regions to 3d slices", params2DTo3D));
5380 imageToImageTests->addChild(imgToImg3dImagesTests.release());
5382 copiesAndBlittingTests->addChild(imageToImageTests.release());
5383 copiesAndBlittingTests->addChild(imageToBufferTests.release());
5384 copiesAndBlittingTests->addChild(bufferToImageTests.release());
5385 copiesAndBlittingTests->addChild(bufferToBufferTests.release());
5386 copiesAndBlittingTests->addChild(blittingImageTests.release());
5387 copiesAndBlittingTests->addChild(resolveImageTests.release());
5389 return copiesAndBlittingTests.release();