projects / platform / upstream / VK-GL-CTS.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 916d873)
Move texture parameter checking to checkSupport()
authorPawel Ksiezopolski <pawel.ksiezopolski@mobica.com>
Tue, 16 Jun 2020 15:18:43 +0000 (17:18 +0200)
committerAlexander Galazin <Alexander.Galazin@arm.com>
Fri, 26 Jun 2020 11:12:15 +0000 (07:12 -0400)
Some of the texture tests use iterate() method to check
if proper extensions are supported.
These checks have been moved to checkSupport() method.

Affects tests:
dEQP-VK.texture.filtering.*
dEQP-VK.texture.compressed.*
dEQP-VK.texture.mipmap.*
dEQP-VK.texture.shadow.*

Components: Vulkan

Change-Id: I21d41c52809e26860c8c39a98aa66817f335feca

external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp patch | blob | history
external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp patch | blob | history

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
index 6f46bad..e04bd00 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
@@ -44,6 +44,93 @@ namespace vkt
 {
 namespace texture
 {
+namespace util
+{
+
+template <>
+void checkTextureSupport (Context& context, const Texture2DTestCaseParameters& testParameters)
+{
+       if (testParameters.minFilter == tcu::Sampler::Sampler::CUBIC || testParameters.minFilter == tcu::Sampler::Sampler::CUBIC_MIPMAP_NEAREST || testParameters.minFilter == tcu::Sampler::Sampler::CUBIC_MIPMAP_LINEAR ||
+               testParameters.magFilter == tcu::Sampler::Sampler::CUBIC)
+       {
+               context.requireDeviceFunctionality("VK_EXT_filter_cubic");
+
+               // check if image format supports cubic filtering
+               const vk::VkPhysicalDeviceImageViewImageFormatInfoEXT imageViewImageFormatInfo =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,             // VkStructureType    sType;
+                       DE_NULL,                                                                                                                                // void*              pNext;
+                       VK_IMAGE_VIEW_TYPE_2D                                                                                                   // VkImageViewType    imageViewType;
+               };
+
+               const vk::VkPhysicalDeviceImageFormatInfo2 formatInfo =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,                                  // VkStructureType       sType;
+                       &imageViewImageFormatInfo,                                                                                              // const void*           pNext;
+                       testParameters.format,                                                                                                  // VkFormat              format;
+                       VK_IMAGE_TYPE_2D,                                                                                                               // VkImageType           type;
+                       VK_IMAGE_TILING_OPTIMAL,                                                                                                // VkImageTiling         tiling;
+                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                       VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                       VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                                // VkImageUsageFlags     usage;
+                       0u                                                                                                                                              // VkImageCreateFlags    flags;
+               };
+
+               vk::VkFilterCubicImageViewImageFormatPropertiesEXT cubicImageViewProperties =
+               {
+                       VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,  // VkStructureType      sType;
+                       DE_NULL,                                                                                                                                // void*                        pNext;
+                       DE_FALSE,                                                                                                                               // VkBool32             filterCubic;
+                       DE_FALSE                                                                                                                                // VkBool32             filterCubicMinmax;
+               };
+
+               vk::VkImageFormatProperties2 formatProperties =
+               {
+                       VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,                                                    // VkStructureType                      sType;
+                       &cubicImageViewProperties,                                                                                              // void*                                        pNext;
+                       vk::VkImageFormatProperties()                                                                                   // VkImageFormatProperties      imageFormatProperties;
+               };
+
+               const vk::VkResult res = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &formatInfo, &formatProperties);
+               if (res == vk::VK_ERROR_FORMAT_NOT_SUPPORTED)
+                       TCU_THROW(NotSupportedError, "Image format not supported");
+               VK_CHECK(res);
+
+               if (!cubicImageViewProperties.filterCubic)
+                       TCU_THROW(NotSupportedError, "Image format does not support cubic filtering");
+
+               VkFormatProperties formatProps;
+               context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), testParameters.format, &formatProps);
+               if ((formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT) == 0)
+                       TCU_THROW(NotSupportedError, "Format properties do not support cubic filtering feature");
+       }
+
+       if (testParameters.wrapS == tcu::Sampler::Sampler::MIRRORED_ONCE || testParameters.wrapT == tcu::Sampler::Sampler::MIRRORED_ONCE)
+               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
+}
+
+template <>
+void checkTextureSupport (Context& context, const TextureCubeTestCaseParameters& testParameters)
+{
+       if (testParameters.wrapS == tcu::Sampler::Sampler::MIRRORED_ONCE || testParameters.wrapT == tcu::Sampler::Sampler::MIRRORED_ONCE)
+               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
+}
+
+template <>
+void checkTextureSupport (Context& context, const Texture2DArrayTestCaseParameters& testParameters)
+{
+       if (testParameters.wrapS == tcu::Sampler::Sampler::MIRRORED_ONCE || testParameters.wrapT == tcu::Sampler::Sampler::MIRRORED_ONCE)
+               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
+}
+
+template <>
+void checkTextureSupport (Context& context, const Texture3DTestCaseParameters& testParameters)
+{
+       if (testParameters.wrapS == tcu::Sampler::Sampler::MIRRORED_ONCE || testParameters.wrapT == tcu::Sampler::Sampler::MIRRORED_ONCE || testParameters.wrapR == tcu::Sampler::Sampler::MIRRORED_ONCE)
+               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
+}
+
+} // util
 
 namespace
 {
@@ -131,9 +218,6 @@ Texture2DFilteringTestInstance::Texture2DFilteringTestInstance (Context& context
                cScale                                                                                          = fmtInfo.valueMax - fmtInfo.valueMin;
        }
 
-       if (testParameters.wrapS == Sampler::MIRRORED_ONCE || testParameters.wrapT == Sampler::MIRRORED_ONCE)
-               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
-
        // Create 2 textures.
        m_textures.reserve(2);
        for (int ndx = 0; ndx < 2; ndx++)
@@ -213,58 +297,6 @@ Texture2DFilteringTestInstance::~Texture2DFilteringTestInstance (void)
 tcu::TestStatus Texture2DFilteringTestInstance::iterate (void)
 {
        tcu::TestLog&                                   log                     = m_context.getTestContext().getLog();
-
-       if (m_testParameters.minFilter == Sampler::CUBIC || m_testParameters.minFilter == Sampler::CUBIC_MIPMAP_NEAREST || m_testParameters.minFilter == Sampler::CUBIC_MIPMAP_LINEAR ||
-               m_testParameters.magFilter == Sampler::CUBIC)
-       {
-               m_context.requireDeviceFunctionality("VK_EXT_filter_cubic");
-
-               // check if image format supports cubic filtering
-               const vk::VkPhysicalDeviceImageViewImageFormatInfoEXT imageViewImageFormatInfo = {
-                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,             // VkStructureType    sType;
-                       DE_NULL,                                                                                                                                // void*              pNext;
-                       VK_IMAGE_VIEW_TYPE_2D                                                                                                   // VkImageViewType    imageViewType;
-               };
-
-               const vk::VkPhysicalDeviceImageFormatInfo2 formatInfo = {
-                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,                                  // VkStructureType       sType;
-                       &imageViewImageFormatInfo,                                                                                              // const void*           pNext;
-                       m_testParameters.format,                                                                                                // VkFormat              format;
-                       VK_IMAGE_TYPE_2D,                                                                                                               // VkImageType           type;
-                       VK_IMAGE_TILING_OPTIMAL,                                                                                                // VkImageTiling         tiling;
-                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                       VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
-                       VK_IMAGE_USAGE_TRANSFER_DST_BIT,                                                                                // VkImageUsageFlags     usage;
-                       0u                                                                                                                                              // VkImageCreateFlags    flags;
-               };
-
-               vk::VkFilterCubicImageViewImageFormatPropertiesEXT cubicImageViewProperties = {
-                       VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,  // VkStructureType      sType;
-                       DE_NULL,                                                                                                                                // void*                        pNext;
-                       DE_FALSE,                                                                                                                               // VkBool32             filterCubic;
-                       DE_FALSE                                                                                                                                // VkBool32             filterCubicMinmax;
-               };
-
-               vk::VkImageFormatProperties2 formatProperties = {
-                       VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,                                                    // VkStructureType                      sType;
-                       &cubicImageViewProperties,                                                                                              // void*                                        pNext;
-                       vk::VkImageFormatProperties()                                                                                   // VkImageFormatProperties      imageFormatProperties;
-               };
-
-               const vk::VkResult res = m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties2(m_context.getPhysicalDevice(), &formatInfo, &formatProperties);
-               if (res == vk::VK_ERROR_FORMAT_NOT_SUPPORTED)
-                       TCU_THROW(NotSupportedError, "Image format not supported");
-               VK_CHECK(res);
-
-               if (!cubicImageViewProperties.filterCubic)
-                       TCU_THROW(NotSupportedError, "Image format does not support cubic filtering");
-
-               VkFormatProperties formatProps;
-               m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), m_testParameters.format, &formatProps);
-               if ((formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT) == 0)
-                       TCU_THROW(NotSupportedError, "Format properties do not support cubic filtering feature");
-       }
-
        const pipeline::TestTexture2D&  texture         = m_renderer.get2DTexture(m_cases[m_caseNdx].textureIndex);
        const tcu::TextureFormat                texFmt          = texture.getTextureFormat();
        const tcu::TextureFormatInfo    fmtInfo         = tcu::getTextureFormatInfo(texFmt);
@@ -402,9 +434,6 @@ TextureCubeFilteringTestInstance::TextureCubeFilteringTestInstance (Context& con
                cScale                                                                                          = fmtInfo.valueMax - fmtInfo.valueMin;
        }
 
-       if (testParameters.wrapS == Sampler::MIRRORED_ONCE || testParameters.wrapT == Sampler::MIRRORED_ONCE)
-               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
-
        m_textures.reserve(2);
        for (int ndx = 0; ndx < 2; ndx++)
                m_textures.push_back(TestTextureCubeSp(new pipeline::TestTextureCube(vk::mapVkFormat(m_testParameters.format), m_testParameters.size)));
@@ -648,9 +677,6 @@ Texture2DArrayFilteringTestInstance::Texture2DArrayFilteringTestInstance (Contex
                cScale                                                                                          = fmtInfo.valueMax - fmtInfo.valueMin;
        }
 
-       if (testParameters.wrapS == Sampler::MIRRORED_ONCE || testParameters.wrapT == Sampler::MIRRORED_ONCE)
-               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
-
        // Create textures.
        m_textures.reserve(2);
        for (int ndx = 0; ndx < 2; ndx++)
@@ -869,9 +895,6 @@ Texture3DFilteringTestInstance::Texture3DFilteringTestInstance (Context& context
                cScale                                                                                          = fmtInfo.valueMax - fmtInfo.valueMin;
        }
 
-       if (testParameters.wrapS == Sampler::MIRRORED_ONCE || testParameters.wrapT == Sampler::MIRRORED_ONCE || testParameters.wrapR == Sampler::MIRRORED_ONCE)
-               context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
-
        // Create textures.
        m_textures.reserve(2);
        for (int ndx = 0; ndx < 2; ndx++)
diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp
index 840773c..89f582b 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureTestUtil.hpp
@@ -280,6 +280,14 @@ tcu::Sampler createSampler (tcu::Sampler::WrapMode wrapU, tcu::Sampler::FilterMo
 TestTexture2DSp loadTexture2D (const tcu::Archive& archive, const std::vector<std::string>& filenames);
 TestTextureCubeSp loadTextureCube (const tcu::Archive& archive, const std::vector<std::string>& filenames);
 
+// Add checkTextureSupport() function specialization for your test parameters class/struct if you need to use checkSupport() functionality
+template <typename T>
+void checkTextureSupport (Context& context, const T& testParameters)
+{
+       DE_UNREF(context);
+       DE_UNREF(testParameters);
+}
+
 template <typename INSTANCE_TYPE>
 class TextureTestCase : public TestCase
 {
@@ -298,6 +306,11 @@ public:
                                                                                {
                                                                                        initializePrograms(programCollection, m_testsParameters.texCoordPrecision, m_testsParameters.programs);
                                                                                }
+       virtual void                                            checkSupport                            (Context& context) const
+                                                                               {
+                                                                                       checkTextureSupport(context, m_testsParameters);
+                                                                               }
+
 
 protected:
        const typename INSTANCE_TYPE::ParameterType m_testsParameters;
Domain: Graphics System / GL;