Support VK_KHR_swapchain_mutable_format

When the device supports VK_KHR_swapchain_mutable_format, a surface
configured with viewFormats no longer needs the blit fallback: the
swapchain is created with VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR
and a VkImageFormatListCreateInfo listing the base format and the
viewFormats, and the wrapped texture descriptor carries the
viewFormats so views can reinterpret the swapchain images directly.

The SurfaceTests case is extended to render through the reinterpreted
srgb view instead of only acquiring the texture.

Change-Id: If6557d1600bb45f18c4889c794b924a8fdc49fe9

Author: wcandillon

src/dawn/native/vulkan/SwapChainVk.cpp

@@ -195,6 +195,25 @@ MaybeError SwapChain::Initialize(SwapChainBase* previousSwapChain) {
     createInfo.clipped = VK_FALSE;
     createInfo.oldSwapchain = previousVkSwapChain;
 
+    // Create the swapchain images with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT so they can be
+    // reinterpreted to the configuration's viewFormats. VK_KHR_swapchain_mutable_format requires
+    // the full list of formats to be provided, including the image format itself.
+    VkImageFormatListCreateInfo imageFormatListInfo;
+    std::vector<VkFormat> viewFormats;
+    if (!mConfig.wgpuViewFormats.empty()) {
+        DAWN_ASSERT(device->GetDeviceInfo().HasExt(DeviceExt::SwapchainMutableFormat));
+        createInfo.flags |= VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR;
+        viewFormats.push_back(mConfig.format);
+        for (wgpu::TextureFormat viewFormat : mConfig.wgpuViewFormats) {
+            viewFormats.push_back(VulkanImageFormat(device, viewFormat));
+        }
+        imageFormatListInfo.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
+        imageFormatListInfo.pNext = nullptr;
+        imageFormatListInfo.viewFormatCount = static_cast<uint32_t>(viewFormats.size());
+        imageFormatListInfo.pViewFormats = viewFormats.data();
+        createInfo.pNext = &imageFormatListInfo;
+    }
+
     DAWN_TRY(CheckVkSuccess(
         device->fn.CreateSwapchainKHR(device->GetVkDevice(), &createInfo, nullptr, &*mSwapChain),
         "CreateSwapChain"));
@@ -272,14 +291,20 @@ ResultOrError<SwapChain::Config> SwapChain::ChooseConfig(
     VkImageUsageFlags targetUsages =
         VulkanImageUsage(GetDevice(), GetUsage(), GetDevice()->GetValidInternalFormat(GetFormat()));
     VkImageUsageFlags supportedUsages = surfaceInfo.capabilities.supportedUsageFlags;
-    // The swapchain images are also unable to satisfy viewFormats: they are
-    // created without VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, so they cannot be
-    // reinterpreted. The blit texture is a regular texture and can.
-    if (!IsSubset(targetUsages, supportedUsages) || !GetViewFormats().empty()) {
-        config.needsBlit = true;
-    } else {
+    // The swapchain images support the configuration's viewFormats only if they are created
+    // with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, which requires VK_KHR_swapchain_mutable_format.
+    // Otherwise the blit texture, a regular texture, is used to support them.
+    const bool viewFormatsSupported =
+        GetViewFormats().empty() ||
+        ToBackend(GetDevice())->GetDeviceInfo().HasExt(DeviceExt::SwapchainMutableFormat);
+    if (IsSubset(targetUsages, supportedUsages) && viewFormatsSupported) {
         config.usage = targetUsages;
         config.wgpuUsage = GetUsage();
+        // The swapchain will be created with VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR so the
+        // images can be reinterpreted to these formats.
+        config.wgpuViewFormats = GetViewFormats();
+    } else {
+        config.needsBlit = true;
     }
 
     // Only support BGRA8Unorm (and RGBA8Unorm on android) with SRGB color space for now.
@@ -548,12 +573,13 @@ ResultOrError<SwapChainTextureInfo> SwapChain::GetCurrentTextureInternal(bool is
     }
     lastImage.lastAcquireDoneFence = std::move(acquireFence);
 
-    // Wait on the previous fence and destroy it.
+    // Wrap the swapchain texture.
     TextureDescriptor textureDesc;
     textureDesc.size.width = mConfig.extent.width;
     textureDesc.size.height = mConfig.extent.height;
     textureDesc.format = mConfig.wgpuFormat;
     textureDesc.usage = mConfig.wgpuUsage;
+    textureDesc.viewFormats = mConfig.wgpuViewFormats;
 
     mTexture = SwapChainTexture::Create(device, Unpack(&textureDesc), lastImage.image);
 
@@ -563,8 +589,9 @@ ResultOrError<SwapChainTextureInfo> SwapChain::GetCurrentTextureInternal(bool is
         return swapChainTextureInfo;
     }
 
-    // The blit texture always perfectly matches what the user requested for the swapchain.
-    // We need to add the Vulkan TRANSFER_SRC flag for the vkCmdBlitImage call.
+    // The blit texture always perfectly matches what the user requested for the swapchain,
+    // including the viewFormats which GetSwapChainBaseTextureDescriptor() carries over. We need
+    // to add the Vulkan TRANSFER_SRC flag for the vkCmdBlitImage call.
     TextureDescriptor desc = GetSwapChainBaseTextureDescriptor(this);
     DAWN_TRY_ASSIGN(mBlitTexture, InternalTexture::Create(device, Unpack(&desc),
                                                           VK_IMAGE_USAGE_TRANSFER_SRC_BIT));

src/dawn/native/vulkan/SwapChainVk.h

@@ -71,6 +71,10 @@ class SwapChain : public SwapChainBase {
         // encapsulates the native swapchain texture.
         wgpu::TextureUsage wgpuUsage;
         wgpu::TextureFormat wgpuFormat;
+        // When non-empty, the swapchain is created with
+        // VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR so its images can be reinterpreted to
+        // these formats, and the wrapped texture exposes them as its viewFormats.
+        std::vector<wgpu::TextureFormat> wgpuViewFormats;
 
         // Information about the blit workarounds we need to do (if any)
         bool needsBlit = false;

src/dawn/native/vulkan/VulkanExtensions.cpp

@@ -149,6 +149,7 @@ static constexpr std::array<DeviceExtInfo, kDeviceExtCount> sDeviceExtInfos{{
     {DeviceExt::DepthClipEnable, "VK_EXT_depth_clip_enable"},
     {DeviceExt::ImageDrmFormatModifier, "VK_EXT_image_drm_format_modifier"},
     {DeviceExt::Swapchain, "VK_KHR_swapchain"},
+    {DeviceExt::SwapchainMutableFormat, "VK_KHR_swapchain_mutable_format"},
     {DeviceExt::QueueFamilyForeign, "VK_EXT_queue_family_foreign"},
     {DeviceExt::Robustness2, "VK_EXT_robustness2"},
     {DeviceExt::DisplayTiming, "VK_GOOGLE_display_timing"},
@@ -253,6 +254,12 @@ DeviceExtSet EnsureDependencies(const DeviceExtSet& advertisedExts,
                 hasDependencies = instanceExts[InstanceExt::Surface];
                 break;
 
+            // Also requires VK_KHR_maintenance2 which is core in Vulkan 1.1.
+            case DeviceExt::SwapchainMutableFormat:
+                hasDependencies =
+                    HasDep(DeviceExt::Swapchain) && HasDep(DeviceExt::ImageFormatList);
+                break;
+
             case DeviceExt::ExternalMemoryAndroidHardwareBuffer:
                 hasDependencies = HasDep(DeviceExt::QueueFamilyForeign);
                 break;

src/dawn/native/vulkan/VulkanExtensions.h

@@ -108,6 +108,7 @@ enum class DeviceExt : uint32_t {
     DepthClipEnable,
     ImageDrmFormatModifier,
     Swapchain,
+    SwapchainMutableFormat,
     QueueFamilyForeign,
     Robustness2,
     DisplayTiming,

src/dawn/tests/end2end/SurfaceTests.cpp

@@ -722,6 +722,8 @@ TEST_P(SurfaceTests, Storage) {
 // Test acquiring a texture from a surface configured with viewFormats.
 TEST_P(SurfaceTests, ConfigureWithViewFormats) {
     wgpu::Surface surface = CreateTestSurface();
+    wgpu::SurfaceCapabilities caps;
+    surface.GetCapabilities(adapter, &caps);
     wgpu::SurfaceConfiguration config = GetPreferredConfiguration(surface);
 
     // Reinterpretation between a format and its srgb counterpart is always
@@ -739,11 +741,37 @@ TEST_P(SurfaceTests, ConfigureWithViewFormats) {
     }
     config.viewFormatCount = 1;
     config.viewFormats = &viewFormat;
+    // When supported, also request CopySrc so the reinterpreted values can be read back.
+    if (caps.usages & wgpu::TextureUsage::CopySrc) {
+        config.usage |= wgpu::TextureUsage::CopySrc;
+    }
     surface.Configure(&config);
 
     wgpu::SurfaceTexture surfaceTexture;
     surface.GetCurrentTexture(&surfaceTexture);  // aborts on Vulkan before the fix
-    ClearTexture(surfaceTexture.texture, {1.0, 0.0, 0.0, 1.0});
+
+    // Clear through a view using the reinterpreted format to check the texture really
+    // supports its viewFormats.
+    wgpu::TextureViewDescriptor viewDesc;
+    viewDesc.format = viewFormat;
+    utils::ComboRenderPassDescriptor renderPassDesc({surfaceTexture.texture.CreateView(&viewDesc)});
+    renderPassDesc.cColorAttachments[0].loadOp = wgpu::LoadOp::Clear;
+    renderPassDesc.cColorAttachments[0].clearValue = {0.5, 0.5, 0.5, 1.0};
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPassDesc);
+    pass.End();
+    wgpu::CommandBuffer commands = encoder.Finish();
+    queue.Submit(1, &commands);
+
+    if (surfaceTexture.texture.GetUsage() & wgpu::TextureUsage::CopySrc) {
+        // The sRGB view encodes the linear 0.5 clear value to ~0.735 on store, so the raw
+        // non-sRGB pixels read back as ~187.5 instead of 128 if the reinterpretation took
+        // effect. A gray value keeps the check independent of the BGRA/RGBA channel order.
+        EXPECT_PIXEL_RGBA8_BETWEEN(utils::RGBA8(187, 187, 187, 255),
+                                   utils::RGBA8(188, 188, 188, 255), surfaceTexture.texture, 0, 0);
+    }
+
     surface.Present();
 }