Handle mixed samples attachments (V2) (shadps4-emu#3667)

* video_core: Refactor render target bind to allow disabling MSAA

* video_core: Implement swapping of backing samples

* clang format

* video_core: Better implementation

Instead of downgrading to 1 sample, always try to match depth samples. This avoids needing to copy depth-stencil attachment and copying multisampled stencil is not possible on some vendors

* video_core: Small bugfixes

* image: Add null check

* vk_rasterizer: Swap backing samples on resolve dst

* vk_presenter: Reset backing samples before present

* video_core: Small refactor to make this implementation better

* reinterpret: Fix channel check for degamma

Seems this was simpler than I thought, hardware doesn't apply degamma on the W channel regardless of swizzle

* image: Add missing end rendering call

* blit_helper: Fix bug in old reinterpret path

* blit_helper: Remove unused layer vertex

Should be used in the future if copying many layers is needed

* vk_rasterizer: Apply suggestion

* vk_rasterizer: More bind refactor

* vk_instance: Re-enable extensions

Author: raphaelthegreat

src/core/libraries/videoout/driver.cpp

@@ -233,29 +233,23 @@ bool VideoOutDriver::SubmitFlip(VideoOutPort* port, s32 index, s64 flip_arg,
     }
 
     if (!is_eop) {
-        // Before processing the flip we need to ask GPU thread to flush command list as at this
-        // point VO surface is ready to be presented, and we will need have an actual state of
-        // Vulkan image at the time of frame presentation.
-        liverpool->SendCommand([=, this]() {
-            presenter->FlushDraw();
-            SubmitFlipInternal(port, index, flip_arg, is_eop);
-        });
+        // Non EOP flips can arrive from any thread so ask GPU thread to perform them
+        liverpool->SendCommand([=, this]() { SubmitFlipInternal(port, index, flip_arg, is_eop); });
     } else {
         SubmitFlipInternal(port, index, flip_arg, is_eop);
     }
 
     return true;
 }
 
-void VideoOutDriver::SubmitFlipInternal(VideoOutPort* port, s32 index, s64 flip_arg,
-                                        bool is_eop /*= false*/) {
+void VideoOutDriver::SubmitFlipInternal(VideoOutPort* port, s32 index, s64 flip_arg, bool is_eop) {
     Vulkan::Frame* frame;
     if (index == -1) {
-        frame = presenter->PrepareBlankFrame(is_eop);
+        frame = presenter->PrepareBlankFrame(false);
     } else {
         const auto& buffer = port->buffer_slots[index];
         const auto& group = port->groups[buffer.group_index];
-        frame = presenter->PrepareFrame(group, buffer.address_left, is_eop);
+        frame = presenter->PrepareFrame(group, buffer.address_left);
     }
 
     std::scoped_lock lock{mutex};

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -301,7 +301,8 @@ void SetupCapabilities(const Info& info, const Profile& profile, const RuntimeIn
             ctx.AddExtension("SPV_KHR_fragment_shader_barycentric");
             ctx.AddCapability(spv::Capability::FragmentBarycentricKHR);
         }
-        if (runtime_info.fs_info.addr_flags.linear_sample_ena ||
+        if (info.loads.Get(IR::Attribute::SampleIndex) ||
+            runtime_info.fs_info.addr_flags.linear_sample_ena ||
             runtime_info.fs_info.addr_flags.persp_sample_ena) {
             ctx.AddCapability(spv::Capability::SampleRateShading);
         }

src/shader_recompiler/frontend/fetch_shader.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <optional>
 #include <vector>
 #include "common/types.h"
 #include "shader_recompiler/info.h"

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -1022,7 +1022,7 @@ void PatchImageSampleArgs(IR::Block& block, IR::Inst& inst, Info& info,
 
     auto converted = ApplyReadNumberConversionVec4(ir, texel, image.GetNumberConversion());
     if (sampler.force_degamma && image.GetNumberFmt() != AmdGpu::NumberFormat::Srgb) {
-        converted = ApplyForceDegamma(ir, texel, image.DstSelect());
+        converted = ApplyForceDegamma(ir, texel);
     }
     inst.ReplaceUsesWith(converted);
 }

src/shader_recompiler/ir/reinterpret.h

@@ -29,25 +29,15 @@ inline F32 ApplyGammaToLinear(IREmitter& ir, const F32& c) {
     return IR::F32{ir.Select(ir.FPGreaterThan(c, ir.Imm32(0.04045f)), a, b)};
 }
 
-inline Value ApplyForceDegamma(IREmitter& ir, const Value& value,
-                               const AmdGpu::CompMapping& mapping) {
+inline Value ApplyForceDegamma(IREmitter& ir, const Value& value) {
     auto x = F32{ir.CompositeExtract(value, 0)};
     auto y = F32{ir.CompositeExtract(value, 1)};
     auto z = F32{ir.CompositeExtract(value, 2)};
     auto w = F32{ir.CompositeExtract(value, 3)};
     // Gamma correction is only applied to RGB components
-    if (AmdGpu::IsRgb(mapping.r)) {
-        x = ApplyGammaToLinear(ir, x);
-    }
-    if (AmdGpu::IsRgb(mapping.g)) {
-        y = ApplyGammaToLinear(ir, y);
-    }
-    if (AmdGpu::IsRgb(mapping.b)) {
-        z = ApplyGammaToLinear(ir, z);
-    }
-    if (AmdGpu::IsRgb(mapping.a)) {
-        w = ApplyGammaToLinear(ir, w);
-    }
+    x = ApplyGammaToLinear(ir, x);
+    y = ApplyGammaToLinear(ir, y);
+    z = ApplyGammaToLinear(ir, z);
     return ir.CompositeConstruct(x, y, z, w);
 }
 

src/video_core/amdgpu/liverpool.h

@@ -1485,26 +1485,6 @@ struct Liverpool {
             return nullptr;
         }
 
-        u32 NumSamples() const {
-            // It seems that the number of samples > 1 set in the AA config doesn't mean we're
-            // always rendering with MSAA, so we need to derive MS ratio from the CB and DB
-            // settings.
-            u32 num_samples = 1u;
-            if (color_control.mode != ColorControl::OperationMode::Disable) {
-                for (auto cb = 0u; cb < NumColorBuffers; ++cb) {
-                    const auto& col_buf = color_buffers[cb];
-                    if (!col_buf) {
-                        continue;
-                    }
-                    num_samples = std::max(num_samples, col_buf.NumSamples());
-                }
-            }
-            if (depth_buffer.DepthValid() || depth_buffer.StencilValid()) {
-                num_samples = std::max(num_samples, depth_buffer.NumSamples());
-            }
-            return num_samples;
-        }
-
         bool IsClipDisabled() const {
             return clipper_control.clip_disable || primitive_type == PrimitiveType::RectList;
         }

src/video_core/buffer_cache/buffer_cache.cpp

@@ -984,44 +984,8 @@ bool BufferCache::SynchronizeBufferFromImage(Buffer& buffer, VAddr device_addr,
     if (copy_size == 0) {
         return false;
     }
-    scheduler.EndRendering();
-    const vk::BufferMemoryBarrier2 pre_barrier = {
-        .srcStageMask = vk::PipelineStageFlagBits2::eAllCommands,
-        .srcAccessMask = vk::AccessFlagBits2::eMemoryRead,
-        .dstStageMask = vk::PipelineStageFlagBits2::eTransfer,
-        .dstAccessMask = vk::AccessFlagBits2::eTransferWrite,
-        .buffer = buffer.Handle(),
-        .offset = buf_offset,
-        .size = copy_size,
-    };
-    const vk::BufferMemoryBarrier2 post_barrier = {
-        .srcStageMask = vk::PipelineStageFlagBits2::eTransfer,
-        .srcAccessMask = vk::AccessFlagBits2::eTransferWrite,
-        .dstStageMask = vk::PipelineStageFlagBits2::eAllCommands,
-        .dstAccessMask = vk::AccessFlagBits2::eMemoryRead,
-        .buffer = buffer.Handle(),
-        .offset = buf_offset,
-        .size = copy_size,
-    };
-    auto barriers =
-        image.GetBarriers(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead,
-                          vk::PipelineStageFlagBits2::eTransfer, {});
-    auto cmdbuf = scheduler.CommandBuffer();
-    cmdbuf.pipelineBarrier2(vk::DependencyInfo{
-        .dependencyFlags = vk::DependencyFlagBits::eByRegion,
-        .bufferMemoryBarrierCount = 1,
-        .pBufferMemoryBarriers = &pre_barrier,
-        .imageMemoryBarrierCount = static_cast<u32>(barriers.size()),
-        .pImageMemoryBarriers = barriers.data(),
-    });
     auto& tile_manager = texture_cache.GetTileManager();
-    tile_manager.TileImage(image.image, buffer_copies, buffer.Handle(), buf_offset, image.info);
-    cmdbuf = scheduler.CommandBuffer();
-    cmdbuf.pipelineBarrier2(vk::DependencyInfo{
-        .dependencyFlags = vk::DependencyFlagBits::eByRegion,
-        .bufferMemoryBarrierCount = 1,
-        .pBufferMemoryBarriers = &post_barrier,
-    });
+    tile_manager.TileImage(image, buffer_copies, buffer.Handle(), buf_offset, copy_size);
     return true;
 }
 

src/video_core/host_shaders/CMakeLists.txt

@@ -12,6 +12,7 @@ set(SHADER_FILES
     detilers/micro_64bpp.comp
     detilers/micro_8bpp.comp
     color_to_ms_depth.frag
+    ms_image_blit.frag
     fault_buffer_process.comp
     fs_tri.vert
     fsr.comp

src/video_core/host_shaders/fs_tri.vert

@@ -3,6 +3,10 @@
 
 #version 450
 
+#if defined(INSTANCE_AS_LAYER)
+#extension GL_ARB_shader_viewport_layer_array : require
+#endif
+
 layout(location = 0) out vec2 uv;
 
 void main() {
@@ -11,5 +15,8 @@ void main() {
         float((gl_VertexIndex & 2u) << 1u)
     );
     gl_Position = vec4(pos - vec2(1.0, 1.0), 0.0, 1.0);
+#if defined(INSTANCE_AS_LAYER)
+    gl_Layer = gl_InstanceIndex;
+#endif
     uv = pos * 0.5;
 }

src/video_core/host_shaders/ms_image_blit.frag

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 450 core
+#extension GL_EXT_samplerless_texture_functions : require
+
+#if defined(SRC_MSAA)
+layout (binding = 0, set = 0) uniform texture2DMS in_tex;
+#else
+layout (binding = 0, set = 0) uniform texture2D in_tex;
+#endif
+
+layout (location = 0) in vec2 uv;
+layout (location = 0) out vec4 out_color;
+
+void main()
+{
+#if defined(SRC_MSAA)
+    out_color = texelFetch(in_tex, ivec2(gl_FragCoord.xy), gl_SampleID);
+#else
+    out_color = texelFetch(in_tex, ivec2(gl_FragCoord.xy), 0);
+#endif
+}