Compute usage from format properties cache in glTexStorageMem2DEXT

src/libANGLE/renderer/vulkan/MemoryObjectVk.cpp

@@ -87,16 +87,10 @@ angle::Result MemoryObjectVk::createImage(const gl::Context *context,
 
     const vk::Format &vkFormat = renderer->getFormat(internalFormat);
 
-    static constexpr VkImageUsageFlags kAllImageUsageFlags =
-        VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
-        VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
-        VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
-
     // All supported usage flags must be specified.
     // See EXT_external_objects issue 13.
-    // TODO(spang): Query supported usage for format via vkGetPhysicalDeviceFormatProperties.
-    // http://anglebug.com/3389
-    VkImageUsageFlags imageUsageFlags = kAllImageUsageFlags;
+    VkImageUsageFlags imageUsageFlags =
+        vk::GetMaximalImageUsageFlags(renderer, vkFormat.vkImageFormat);
 
     VkExternalMemoryImageCreateInfo externalMemoryImageCreateInfo = {};
     externalMemoryImageCreateInfo.sType       = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -1824,6 +1824,12 @@ bool RendererVk::hasLinearImageFormatFeatureBits(VkFormat format,
     return hasFormatFeatureBits<&VkFormatProperties::linearTilingFeatures>(format, featureBits);
 }
 
+VkFormatFeatureFlags RendererVk::getImageFormatFeatureBits(VkFormat format,
+                                                           const VkFormatFeatureFlags featureBits)
+{
+    return getFormatFeatureBits<&VkFormatProperties::optimalTilingFeatures>(format, featureBits);
+}
+
 bool RendererVk::hasImageFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits)
 {
     return hasFormatFeatureBits<&VkFormatProperties::optimalTilingFeatures>(format, featureBits);
@@ -2188,7 +2194,8 @@ void RendererVk::flushGpuEvents(double nextSyncGpuTimestampS, double nextSyncCpu
 }
 
 template <VkFormatFeatureFlags VkFormatProperties::*features>
-bool RendererVk::hasFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits)
+VkFormatFeatureFlags RendererVk::getFormatFeatureBits(VkFormat format,
+                                                      const VkFormatFeatureFlags featureBits)
 {
     ASSERT(static_cast<uint32_t>(format) < vk::kNumVkFormats);
     VkFormatProperties &deviceProperties = mFormatProperties[format];
@@ -2200,14 +2207,20 @@ bool RendererVk::hasFormatFeatureBits(VkFormat format, const VkFormatFeatureFlag
         const VkFormatProperties &mandatoryProperties = vk::GetMandatoryFormatSupport(format);
         if (IsMaskFlagSet(mandatoryProperties.*features, featureBits))
         {
-            return true;
+            return featureBits;
         }
 
         // Otherwise query the format features and cache it.
         vkGetPhysicalDeviceFormatProperties(mPhysicalDevice, format, &deviceProperties);
     }
 
-    return IsMaskFlagSet(deviceProperties.*features, featureBits);
+    return deviceProperties.*features & featureBits;
+}
+
+template <VkFormatFeatureFlags VkFormatProperties::*features>
+bool RendererVk::hasFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits)
+{
+    return IsMaskFlagSet(getFormatFeatureBits<features>(format, featureBits), featureBits);
 }
 
 uint32_t GetUniformBufferDescriptorCount()

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -203,6 +203,8 @@ class RendererVk : angle::NonCopyable
     // bufferFeatures).  Looks through mandatory features first, and falls back to querying the
     // device (first time only).
     bool hasLinearImageFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits);
+    VkFormatFeatureFlags getImageFormatFeatureBits(VkFormat format,
+                                                   const VkFormatFeatureFlags featureBits);
     bool hasImageFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits);
     bool hasBufferFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits);
 
@@ -243,6 +245,10 @@ class RendererVk : angle::NonCopyable
     void flushGpuEvents(double nextSyncGpuTimestampS, double nextSyncCpuTimestampS);
 
     template <VkFormatFeatureFlags VkFormatProperties::*features>
+    VkFormatFeatureFlags getFormatFeatureBits(VkFormat format,
+                                              const VkFormatFeatureFlags featureBits);
+
+    template <VkFormatFeatureFlags VkFormatProperties::*features>
     bool hasFormatFeatureBits(VkFormat format, const VkFormatFeatureFlags featureBits);
 
     void nextSerial();

src/libANGLE/renderer/vulkan/vk_format_utils.cpp

@@ -240,6 +240,32 @@ void FormatTable::initialize(RendererVk *renderer,
         }
     }
 }
+
+VkImageUsageFlags GetMaximalImageUsageFlags(RendererVk *renderer, VkFormat format)
+{
+    constexpr VkFormatFeatureFlags kImageUsageFeatureBits =
+        VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT |
+        VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
+        VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
+    VkFormatFeatureFlags featureBits =
+        renderer->getImageFormatFeatureBits(format, kImageUsageFeatureBits);
+    VkImageUsageFlags imageUsageFlags = 0;
+    if (featureBits & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT;
+    if (featureBits & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT;
+    if (featureBits & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    if (featureBits & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    if (featureBits & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    if (featureBits & VK_FORMAT_FEATURE_TRANSFER_DST_BIT)
+        imageUsageFlags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    imageUsageFlags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    return imageUsageFlags;
+}
+
 }  // namespace vk
 
 bool HasFullTextureFormatSupport(RendererVk *renderer, VkFormat vkFormat)

src/libANGLE/renderer/vulkan/vk_format_utils.h

@@ -138,6 +138,8 @@ class FormatTable final : angle::NonCopyable
 // initialized to 0.
 const VkFormatProperties &GetMandatoryFormatSupport(VkFormat vkFormat);
 
+VkImageUsageFlags GetMaximalImageUsageFlags(RendererVk *renderer, VkFormat format);
+
 }  // namespace vk
 
 // Checks if a vkFormat supports all the features needed to use it as a GL texture format