1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 The Khronos Group Inc.
6 * Copyright (c) 2016 The Android Open Source Project
7 *
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
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
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.
19 *
20 *//*!
21 * \file
22 * \brief Image load/store utilities
23 *//*--------------------------------------------------------------------*/
24
25 #include "deMath.h"
26 #include "tcuTextureUtil.hpp"
27 #include "vktImageLoadStoreUtil.hpp"
28 #include "vkQueryUtil.hpp"
29
30 using namespace vk;
31
32 namespace vkt
33 {
34 namespace image
35 {
36
computeStoreColorScale(const vk::VkFormat format,const tcu::IVec3 imageSize)37 float computeStoreColorScale (const vk::VkFormat format, const tcu::IVec3 imageSize)
38 {
39 const int maxImageDimension = de::max(imageSize.x(), de::max(imageSize.y(), imageSize.z()));
40 const float div = static_cast<float>(maxImageDimension - 1);
41
42 if (isUnormFormat(format))
43 return 1.0f / div;
44 else if (isSnormFormat(format))
45 return 2.0f / div;
46 else
47 return 1.0f;
48 }
49
getImageTypeForSingleLayer(const ImageType imageType)50 ImageType getImageTypeForSingleLayer (const ImageType imageType)
51 {
52 switch (imageType)
53 {
54 case IMAGE_TYPE_1D:
55 case IMAGE_TYPE_1D_ARRAY:
56 return IMAGE_TYPE_1D;
57
58 case IMAGE_TYPE_2D:
59 case IMAGE_TYPE_2D_ARRAY:
60 case IMAGE_TYPE_CUBE:
61 case IMAGE_TYPE_CUBE_ARRAY:
62 // A single layer for cube is a 2d face
63 return IMAGE_TYPE_2D;
64
65 case IMAGE_TYPE_3D:
66 return IMAGE_TYPE_3D;
67
68 case IMAGE_TYPE_BUFFER:
69 return IMAGE_TYPE_BUFFER;
70
71 default:
72 DE_FATAL("Internal test error");
73 return IMAGE_TYPE_LAST;
74 }
75 }
76
makeImageCreateInfo(const Texture & texture,const VkFormat format,const VkImageUsageFlags usage,const VkImageCreateFlags flags)77 VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags)
78 {
79 const VkSampleCountFlagBits samples = static_cast<VkSampleCountFlagBits>(texture.numSamples()); // integer and bit mask are aligned, so we can cast like this
80
81 const VkImageCreateInfo imageParams =
82 {
83 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
84 DE_NULL, // const void* pNext;
85 (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags;
86 mapImageType(texture.type()), // VkImageType imageType;
87 format, // VkFormat format;
88 makeExtent3D(texture.layerSize()), // VkExtent3D extent;
89 1u, // deUint32 mipLevels;
90 (deUint32)texture.numLayers(), // deUint32 arrayLayers;
91 samples, // VkSampleCountFlagBits samples;
92 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
93 usage, // VkImageUsageFlags usage;
94 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
95 0u, // deUint32 queueFamilyIndexCount;
96 DE_NULL, // const deUint32* pQueueFamilyIndices;
97 VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
98 };
99 return imageParams;
100 }
101
102
103 //! Minimum chunk size is determined by the offset alignment requirements.
getOptimalUniformBufferChunkSize(const InstanceInterface & vki,const VkPhysicalDevice physDevice,VkDeviceSize minimumRequiredChunkSizeBytes)104 VkDeviceSize getOptimalUniformBufferChunkSize (const InstanceInterface& vki, const VkPhysicalDevice physDevice, VkDeviceSize minimumRequiredChunkSizeBytes)
105 {
106 const VkPhysicalDeviceProperties properties = getPhysicalDeviceProperties(vki, physDevice);
107 const VkDeviceSize alignment = properties.limits.minUniformBufferOffsetAlignment;
108
109 if (minimumRequiredChunkSizeBytes > alignment)
110 return alignment + (minimumRequiredChunkSizeBytes / alignment) * alignment;
111 else
112 return alignment;
113 }
114
isRepresentableIntegerValue(tcu::Vector<deInt64,4> value,tcu::TextureFormat format)115 bool isRepresentableIntegerValue (tcu::Vector<deInt64, 4> value, tcu::TextureFormat format)
116 {
117 const tcu::IVec4 formatBitDepths = tcu::getTextureFormatBitDepth(format);
118 const deUint32 numChannels = getNumUsedChannels(mapTextureFormat(format));
119
120 switch (tcu::getTextureChannelClass(format.type))
121 {
122 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
123 {
124 for (deUint32 compNdx = 0; compNdx < numChannels; compNdx++)
125 {
126 if (deFloorToInt32(log2((double)value[compNdx]) + 1) > formatBitDepths[compNdx])
127 return false;
128 }
129
130 break;
131 }
132
133 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
134 {
135 for (deUint32 compNdx = 0; compNdx < numChannels; compNdx++)
136 {
137 if ((deFloorToInt32(log2((double)deAbs64(value[compNdx])) + 1) + 1) > formatBitDepths[compNdx])
138 return false;
139 }
140
141 break;
142 }
143
144 default:
145 DE_ASSERT(isIntegerFormat(mapTextureFormat(format)));
146 }
147
148 return true;
149 }
150
151 } // image
152 } // vkt
153