nvapi-d3d: Fix NV_LATENCY_MARKER_TYPE forwarding

Unfortunately NV_LATENCY_MARKER_TYPE doesn't match
VkLatencyMarkerNV, so we need to convert manually. Silently
acknowledge, but ignore, calls with unsupported values.

Author: jp7677

src/nvapi/nvapi_d3d_low_latency_device.cpp

@@ -1,4 +1,6 @@
 #include "nvapi_d3d_low_latency_device.h"
+#include "../util/util_string.h"
+#include "../util/util_log.h"
 
 namespace dxvk {
     LowLatencyFrameIdGenerator::LowLatencyFrameIdGenerator()
@@ -110,6 +112,32 @@ namespace dxvk {
             GetFrameIdGenerator(d3dLowLatencyDevice.ptr())->GetLowLatencyDeviceFrameId(frameID), markerType));
     }
 
+    std::optional<uint32_t> NvapiD3dLowLatencyDevice::ToMarkerType(NV_LATENCY_MARKER_TYPE markerType) {
+        switch (markerType) {
+            case (SIMULATION_START):
+            case (SIMULATION_END):
+            case (RENDERSUBMIT_START):
+            case (RENDERSUBMIT_END):
+            case (PRESENT_START):
+            case (PRESENT_END):
+            case (INPUT_SAMPLE):
+            case (TRIGGER_FLASH):
+                return markerType;
+            // VkLatencyMarkerNV misses PC_LATENCY_PING and all following enum values are offset
+            // See https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkSetLatencyMarkerInfoNV-marker-parameter
+            case (PC_LATENCY_PING):
+                return {};
+            case (OUT_OF_BAND_RENDERSUBMIT_START):
+            case (OUT_OF_BAND_RENDERSUBMIT_END):
+            case (OUT_OF_BAND_PRESENT_START):
+            case (OUT_OF_BAND_PRESENT_END):
+                return markerType - 1;
+        }
+
+        log::info(str::format("Unknown NV_LATENCY_MARKER_TYPE: ", markerType));
+        return {};
+    }
+
     void NvapiD3dLowLatencyDevice::ClearCacheMaps() {
         std::scoped_lock lock(m_lowLatencyDeviceMutex, m_lowLatencyFrameIdGeneratorMutex);
 

src/nvapi/nvapi_d3d_low_latency_device.h

@@ -33,6 +33,8 @@ namespace dxvk {
         static bool SetLatencyMarker(IUnknown* device, uint64_t frameID, uint32_t markerType);
         static bool SetLatencyMarker(ID3D12CommandQueue* commandQueue, uint64_t frameID, uint32_t markerType);
 
+        [[nodiscard]] static std::optional<uint32_t> ToMarkerType(NV_LATENCY_MARKER_TYPE markerType);
+
         static void ClearCacheMaps();
 
       private:

src/nvapi_d3d.cpp

@@ -256,6 +256,7 @@ extern "C" {
         thread_local bool alreadyLoggedNoImpl = false;
         thread_local bool alreadyLoggedError = false;
         thread_local bool alreadyLoggedOk = false;
+        thread_local bool alreadyLoggedMarkerTypeNotSupported = false;
 
         if (log::tracing())
             log::trace(n, log::fmt::ptr(pDev), log::fmt::nv_latency_marker_params(pSetLatencyMarkerParams));
@@ -272,7 +273,16 @@ extern "C" {
         if (nvapiD3dInstance->IsUsingLfx() || !NvapiD3dLowLatencyDevice::SupportsLowLatency(pDev))
             return NoImplementation(n, alreadyLoggedNoImpl);
 
-        if (!NvapiD3dLowLatencyDevice::SetLatencyMarker(pDev, pSetLatencyMarkerParams->frameID, pSetLatencyMarkerParams->markerType))
+        auto markerType = NvapiD3dLowLatencyDevice::ToMarkerType(pSetLatencyMarkerParams->markerType);
+        if (!markerType.has_value()) {
+            // Silently drop unsupported marker types
+            if (!std::exchange(alreadyLoggedMarkerTypeNotSupported, true))
+                log::info(str::format("Not supported NV_LATENCY_MARKER_TYPE: ", pSetLatencyMarkerParams->markerType));
+
+            return Ok(n, alreadyLoggedOk);
+        }
+
+        if (!NvapiD3dLowLatencyDevice::SetLatencyMarker(pDev, pSetLatencyMarkerParams->frameID, markerType.value()))
             return Error(n, alreadyLoggedError);
 
         return Ok(n, alreadyLoggedOk);

tests/nvapi_d3d.cpp

@@ -383,7 +383,7 @@ TEST_CASE("D3D Reflex/LatencyFleX depending methods succeed", "[.d3d]") {
                     .RETURN(S_OK);
                 REQUIRE_CALL(lowLatencyDevice, LatencySleep())
                     .RETURN(S_OK);
-                REQUIRE_CALL(lowLatencyDevice, SetLatencyMarker(1ULL, SIMULATION_START))
+                REQUIRE_CALL(lowLatencyDevice, SetLatencyMarker(1ULL, VK_LATENCY_MARKER_SIMULATION_START_NV))
                     .RETURN(S_OK);
 
                 SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
@@ -402,6 +402,19 @@ TEST_CASE("D3D Reflex/LatencyFleX depending methods succeed", "[.d3d]") {
                 REQUIRE(NvAPI_D3D_SetLatencyMarker(&unknown, &latencyMarkerParams) == NVAPI_OK);
             }
 
+            SECTION("SetLatencyMarker drops PC_LATENCY_PING and returns OK") {
+                FORBID_CALL(lowLatencyDevice, SetLatencyMarker(_, _));
+
+                SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
+                REQUIRE(NvAPI_Initialize() == NVAPI_OK);
+
+                NV_LATENCY_MARKER_PARAMS latencyMarkerParams{};
+                latencyMarkerParams.version = NV_LATENCY_MARKER_PARAMS_VER1;
+                latencyMarkerParams.frameID = 123ULL;
+                latencyMarkerParams.markerType = PC_LATENCY_PING;
+                REQUIRE(NvAPI_D3D_SetLatencyMarker(&unknown, &latencyMarkerParams) == NVAPI_OK);
+            }
+
             SECTION("SetLatencyMarker correctly produces monotonic frame ids for a sequence of unique application frame ids") {
                 REQUIRE_CALL(lowLatencyDevice, SetLatencySleepMode(true, false, 750U))
                     .RETURN(S_OK);