1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
5 * Copyright (c) 2015 Mobica Ltd.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and/or associated documentation files (the
9 * "Materials"), to deal in the Materials without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sublicense, and/or sell copies of the Materials, and to
12 * permit persons to whom the Materials are furnished to do so, subject to
13 * the following conditions:
15 * The above copyright notice(s) and this permission notice shall be included
16 * in all copies or substantial portions of the Materials.
18 * The Materials are Confidential Information as defined by the
19 * Khronos Membership Agreement until designated non-confidential by Khronos,
20 * at which point this condition clause shall be removed.
22 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
26 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
32 * \brief Image Tests Utility Classes
33 *//*--------------------------------------------------------------------*/
35 #include "vktImageTestsUtil.hpp"
36 #include "vkQueryUtil.hpp"
37 #include "vkTypeUtil.hpp"
38 #include "tcuTextureUtil.hpp"
47 Buffer::Buffer (const DeviceInterface& vk,
48 const VkDevice device,
50 const VkBufferCreateInfo& bufferCreateInfo,
51 const MemoryRequirement memoryRequirement)
53 m_buffer = createBuffer(vk, device, &bufferCreateInfo);
54 m_allocation = allocator.allocate(getBufferMemoryRequirements(vk, device, *m_buffer), memoryRequirement);
55 VK_CHECK(vk.bindBufferMemory(device, *m_buffer, m_allocation->getMemory(), m_allocation->getOffset()));
58 Image::Image (const DeviceInterface& vk,
59 const VkDevice device,
61 const VkImageCreateInfo& imageCreateInfo,
62 const MemoryRequirement memoryRequirement)
64 m_image = createImage(vk, device, &imageCreateInfo);
65 m_allocation = allocator.allocate(getImageMemoryRequirements(vk, device, *m_image), memoryRequirement);
66 VK_CHECK(vk.bindImageMemory(device, *m_image, m_allocation->getMemory(), m_allocation->getOffset()));
69 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize,
70 const VkBufferUsageFlags usage)
72 const VkBufferCreateInfo bufferCreateInfo =
74 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
75 DE_NULL, // const void* pNext;
76 0u, // VkBufferCreateFlags flags;
77 bufferSize, // VkDeviceSize size;
78 usage, // VkBufferUsageFlags usage;
79 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
80 0u, // deUint32 queueFamilyIndexCount;
81 DE_NULL, // const deUint32* pQueueFamilyIndices;
83 return bufferCreateInfo;
86 VkBufferImageCopy makeBufferImageCopy (const VkExtent3D extent,
87 const deUint32 arraySize)
89 const VkBufferImageCopy copyParams =
91 0ull, // VkDeviceSize bufferOffset;
92 0u, // deUint32 bufferRowLength;
93 0u, // deUint32 bufferImageHeight;
94 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, arraySize), // VkImageSubresourceLayers imageSubresource;
95 makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
96 extent, // VkExtent3D imageExtent;
101 Move<VkCommandPool> makeCommandPool (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
103 const VkCommandPoolCreateInfo commandPoolParams =
105 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
106 DE_NULL, // const void* pNext;
107 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // VkCommandPoolCreateFlags flags;
108 queueFamilyIndex, // deUint32 queueFamilyIndex;
110 return createCommandPool(vk, device, &commandPoolParams);
113 Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool)
115 const VkCommandBufferAllocateInfo bufferAllocateParams =
117 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
118 DE_NULL, // const void* pNext;
119 commandPool, // VkCommandPool commandPool;
120 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
121 1u, // deUint32 bufferCount;
123 return allocateCommandBuffer(vk, device, &bufferAllocateParams);
126 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk,
127 const VkDevice device,
128 const VkDescriptorSetLayout descriptorSetLayout)
130 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
132 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
133 DE_NULL, // const void* pNext;
134 0u, // VkPipelineLayoutCreateFlags flags;
135 1u, // deUint32 setLayoutCount;
136 &descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts;
137 0u, // deUint32 pushConstantRangeCount;
138 DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
140 return createPipelineLayout(vk, device, &pipelineLayoutParams);
143 Move<VkPipeline> makeComputePipeline (const DeviceInterface& vk,
144 const VkDevice device,
145 const VkPipelineLayout pipelineLayout,
146 const VkShaderModule shaderModule)
148 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
150 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
151 DE_NULL, // const void* pNext;
152 0u, // VkPipelineShaderStageCreateFlags flags;
153 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
154 shaderModule, // VkShaderModule module;
155 "main", // const char* pName;
156 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
158 const VkComputePipelineCreateInfo pipelineCreateInfo =
160 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
161 DE_NULL, // const void* pNext;
162 0u, // VkPipelineCreateFlags flags;
163 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
164 pipelineLayout, // VkPipelineLayout layout;
165 DE_NULL, // VkPipeline basePipelineHandle;
166 0, // deInt32 basePipelineIndex;
168 return createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo);
171 Move<VkBufferView> makeBufferView (const DeviceInterface& vk,
172 const VkDevice vkDevice,
173 const VkBuffer buffer,
174 const VkFormat format,
175 const VkDeviceSize offset,
176 const VkDeviceSize size)
178 const VkBufferViewCreateInfo bufferViewParams =
180 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType;
181 DE_NULL, // const void* pNext;
182 0u, // VkBufferViewCreateFlags flags;
183 buffer, // VkBuffer buffer;
184 format, // VkFormat format;
185 offset, // VkDeviceSize offset;
186 size, // VkDeviceSize range;
188 return createBufferView(vk, vkDevice, &bufferViewParams);
191 Move<VkImageView> makeImageView (const DeviceInterface& vk,
192 const VkDevice vkDevice,
194 const VkImageViewType imageViewType,
195 const VkFormat format,
196 const VkImageSubresourceRange subresourceRange)
198 const VkImageViewCreateInfo imageViewParams =
200 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
201 DE_NULL, // const void* pNext;
202 0u, // VkImageViewCreateFlags flags;
203 image, // VkImage image;
204 imageViewType, // VkImageViewType viewType;
205 format, // VkFormat format;
206 makeComponentMappingRGBA(), // VkComponentMapping components;
207 subresourceRange, // VkImageSubresourceRange subresourceRange;
209 return createImageView(vk, vkDevice, &imageViewParams);
212 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk,
213 const VkDevice device,
214 const VkDescriptorPool descriptorPool,
215 const VkDescriptorSetLayout setLayout)
217 const VkDescriptorSetAllocateInfo allocateParams =
219 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
220 DE_NULL, // const void* pNext;
221 descriptorPool, // VkDescriptorPool descriptorPool;
222 1u, // deUint32 setLayoutCount;
223 &setLayout, // const VkDescriptorSetLayout* pSetLayouts;
225 return allocateDescriptorSet(vk, device, &allocateParams);
228 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags srcAccessMask,
229 const VkAccessFlags dstAccessMask,
230 const VkBuffer buffer,
231 const VkDeviceSize offset,
232 const VkDeviceSize bufferSizeBytes)
234 const VkBufferMemoryBarrier barrier =
236 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
237 DE_NULL, // const void* pNext;
238 srcAccessMask, // VkAccessFlags srcAccessMask;
239 dstAccessMask, // VkAccessFlags dstAccessMask;
240 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
241 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
242 buffer, // VkBuffer buffer;
243 offset, // VkDeviceSize offset;
244 bufferSizeBytes, // VkDeviceSize size;
249 VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask,
250 const VkAccessFlags dstAccessMask,
251 const VkImageLayout oldLayout,
252 const VkImageLayout newLayout,
254 const VkImageSubresourceRange subresourceRange)
256 const VkImageMemoryBarrier barrier =
258 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
259 DE_NULL, // const void* pNext;
260 srcAccessMask, // VkAccessFlags outputMask;
261 dstAccessMask, // VkAccessFlags inputMask;
262 oldLayout, // VkImageLayout oldLayout;
263 newLayout, // VkImageLayout newLayout;
264 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
265 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
266 image, // VkImage image;
267 subresourceRange, // VkImageSubresourceRange subresourceRange;
272 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
274 const VkCommandBufferBeginInfo commandBufBeginParams =
276 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
277 DE_NULL, // const void* pNext;
278 0u, // VkCommandBufferUsageFlags flags;
279 DE_NULL, // VkRenderPass renderPass;
280 0u, // deUint32 subpass;
281 DE_NULL, // VkFramebuffer framebuffer;
282 DE_FALSE, // VkBool32 occlusionQueryEnable;
283 0u, // VkQueryControlFlags queryFlags;
284 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
286 VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
288 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
290 VK_CHECK(vk.endCommandBuffer(commandBuffer));
293 void submitCommandsAndWait (const DeviceInterface& vk,
294 const VkDevice device,
296 const VkCommandBuffer commandBuffer)
298 const VkFenceCreateInfo fenceParams =
300 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
301 DE_NULL, // const void* pNext;
302 0u, // VkFenceCreateFlags flags;
304 const Unique<VkFence> fence(createFence(vk, device, &fenceParams));
306 const VkSubmitInfo submitInfo =
308 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
309 DE_NULL, // const void* pNext;
310 0u, // deUint32 waitSemaphoreCount;
311 DE_NULL, // const VkSemaphore* pWaitSemaphores;
312 1u, // deUint32 commandBufferCount;
313 &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
314 0u, // deUint32 signalSemaphoreCount;
315 DE_NULL, // const VkSemaphore* pSignalSemaphores;
318 VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
319 VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
322 VkImageType mapImageType (const ImageType imageType)
327 case IMAGE_TYPE_1D_ARRAY:
328 case IMAGE_TYPE_BUFFER:
329 return VK_IMAGE_TYPE_1D;
332 case IMAGE_TYPE_2D_ARRAY:
333 case IMAGE_TYPE_CUBE:
334 case IMAGE_TYPE_CUBE_ARRAY:
335 return VK_IMAGE_TYPE_2D;
338 return VK_IMAGE_TYPE_3D;
342 return VK_IMAGE_TYPE_LAST;
346 VkImageViewType mapImageViewType (const ImageType imageType)
350 case IMAGE_TYPE_1D: return VK_IMAGE_VIEW_TYPE_1D;
351 case IMAGE_TYPE_1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
352 case IMAGE_TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D;
353 case IMAGE_TYPE_2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
354 case IMAGE_TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D;
355 case IMAGE_TYPE_CUBE: return VK_IMAGE_VIEW_TYPE_CUBE;
356 case IMAGE_TYPE_CUBE_ARRAY: return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
360 return VK_IMAGE_VIEW_TYPE_LAST;
364 std::string getImageTypeName (const ImageType imageType)
368 case IMAGE_TYPE_1D: return "1d";
369 case IMAGE_TYPE_1D_ARRAY: return "1d_array";
370 case IMAGE_TYPE_2D: return "2d";
371 case IMAGE_TYPE_2D_ARRAY: return "2d_array";
372 case IMAGE_TYPE_3D: return "3d";
373 case IMAGE_TYPE_CUBE: return "cube";
374 case IMAGE_TYPE_CUBE_ARRAY: return "cube_array";
375 case IMAGE_TYPE_BUFFER: return "buffer";
383 std::string getShaderImageType (const tcu::TextureFormat& format, const ImageType imageType)
385 std::string formatPart = tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ? "u" :
386 tcu::getTextureChannelClass(format.type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER ? "i" : "";
388 std::string imageTypePart;
391 case IMAGE_TYPE_1D: imageTypePart = "1D"; break;
392 case IMAGE_TYPE_1D_ARRAY: imageTypePart = "1DArray"; break;
393 case IMAGE_TYPE_2D: imageTypePart = "2D"; break;
394 case IMAGE_TYPE_2D_ARRAY: imageTypePart = "2DArray"; break;
395 case IMAGE_TYPE_3D: imageTypePart = "3D"; break;
396 case IMAGE_TYPE_CUBE: imageTypePart = "Cube"; break;
397 case IMAGE_TYPE_CUBE_ARRAY: imageTypePart = "CubeArray"; break;
398 case IMAGE_TYPE_BUFFER: imageTypePart = "Buffer"; break;
404 return formatPart + "image" + imageTypePart;
407 std::string getShaderImageFormatQualifier (const tcu::TextureFormat& format)
409 const char* orderPart;
410 const char* typePart;
412 switch (format.order)
414 case tcu::TextureFormat::R: orderPart = "r"; break;
415 case tcu::TextureFormat::RG: orderPart = "rg"; break;
416 case tcu::TextureFormat::RGB: orderPart = "rgb"; break;
417 case tcu::TextureFormat::RGBA: orderPart = "rgba"; break;
426 case tcu::TextureFormat::FLOAT: typePart = "32f"; break;
427 case tcu::TextureFormat::HALF_FLOAT: typePart = "16f"; break;
429 case tcu::TextureFormat::UNSIGNED_INT32: typePart = "32ui"; break;
430 case tcu::TextureFormat::UNSIGNED_INT16: typePart = "16ui"; break;
431 case tcu::TextureFormat::UNSIGNED_INT8: typePart = "8ui"; break;
433 case tcu::TextureFormat::SIGNED_INT32: typePart = "32i"; break;
434 case tcu::TextureFormat::SIGNED_INT16: typePart = "16i"; break;
435 case tcu::TextureFormat::SIGNED_INT8: typePart = "8i"; break;
437 case tcu::TextureFormat::UNORM_INT16: typePart = "16"; break;
438 case tcu::TextureFormat::UNORM_INT8: typePart = "8"; break;
440 case tcu::TextureFormat::SNORM_INT16: typePart = "16_snorm"; break;
441 case tcu::TextureFormat::SNORM_INT8: typePart = "8_snorm"; break;
448 return std::string() + orderPart + typePart;