Win32: Add d3dkmt + Scanline Sync

Author: sonninnos

Makefile.common

@@ -1835,6 +1835,7 @@ ifeq ($(HAVE_D3D12), 1)
    HAVE_D3D_COMMON = 1
    OBJ += gfx/drivers/d3d12.o
    DEFINES += -DHAVE_D3D12
+   DEFINES += -DHAVE_D3DKMT
 endif
 
 ifneq ($(findstring 1, $(HAVE_D3D10) $(HAVE_D3D11) $(HAVE_D3D12)),)

config.def.h

@@ -377,6 +377,7 @@
 
 /* Video VSYNC (recommended) */
 #define DEFAULT_VSYNC true
+#define DEFAULT_SCANLINE_SYNC false
 
 /* Vulkan specific */
 #define DEFAULT_MAX_SWAPCHAIN_IMAGES 3

configuration.c

@@ -1970,6 +1970,7 @@ static struct config_bool_setting *populate_settings_bool(
    SETTING_BOOL("video_hdr_scanlines",           &settings->bools.video_hdr_scanlines, true, DEFAULT_VIDEO_HDR_SCANLINES, false);
    SETTING_BOOL("video_vsync",                   &settings->bools.video_vsync, true, DEFAULT_VSYNC, false);
    SETTING_BOOL("video_adaptive_vsync",          &settings->bools.video_adaptive_vsync, true, DEFAULT_ADAPTIVE_VSYNC, false);
+   SETTING_BOOL("video_scanline_sync",           &settings->bools.video_scanline_sync, true, DEFAULT_SCANLINE_SYNC, false);
    SETTING_BOOL("video_hard_sync",               &settings->bools.video_hard_sync, true, DEFAULT_HARD_SYNC, false);
    SETTING_BOOL("video_waitable_swapchains",     &settings->bools.video_waitable_swapchains, true, DEFAULT_WAITABLE_SWAPCHAINS, false);
    SETTING_BOOL("video_disable_composition",     &settings->bools.video_disable_composition, true, DEFAULT_DISABLE_COMPOSITION, false);

configuration.h

@@ -669,6 +669,7 @@ typedef struct settings
       bool video_windowed_fullscreen;
       bool video_vsync;
       bool video_adaptive_vsync;
+      bool video_scanline_sync;
       bool video_hard_sync;
       bool video_waitable_swapchains;
       bool video_vfilter;

gfx/common/vulkan_common.c

@@ -1831,7 +1831,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
    VkPresentModeKHR swapchain_present_mode = VK_PRESENT_MODE_FIFO_KHR;
    VkCompositeAlphaFlagBitsKHR composite   = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
    settings_t                    *settings = config_get_ptr();
-   bool vsync                              = settings->bools.video_vsync;
+   bool vsync                              = settings->bools.video_vsync && !settings->bools.video_scanline_sync;
    bool adaptive_vsync                     = settings->bools.video_adaptive_vsync;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
    bool video_windowed_fullscreen          = settings->bools.video_windowed_fullscreen;

gfx/common/win32_common.c

@@ -1992,6 +1992,10 @@ bool win32_window_init(WNDCLASSEX *wndclass,
    if (class_name)
       wndclass->style        |= CS_CLASSDC;
 
+#ifdef HAVE_D3DKMT
+   d3dkmt_init();
+#endif
+
    return RegisterClassEx(wndclass);
 }
 
@@ -2099,3 +2103,65 @@ HACCEL win32_resources_get_accelerator(void)
    return s_accel_table;
 }
 #endif /* !__WINRT__ */
+
+#ifdef HAVE_D3DKMT
+void d3dkmt_init(void)
+{
+   if (!pD3DKMTOpenAdapterFromHdc)
+   {
+      unsigned d3dkmt_adapter_hAdapter = 0;
+      unsigned d3dkmt_adapter_VidPnSourceId = 0;
+      unsigned adapter_index = 0;
+      DISPLAY_DEVICE add;
+
+      add.cb = sizeof(add);
+
+      pD3DKMTOpenAdapterFromHdc = (D3DKMTOPENADAPTERFROMHDC)
+            GetProcAddress(GetModuleHandle("gdi32.dll"), "D3DKMTOpenAdapterFromHdc");
+      pD3DKMTGetScanLine = (D3DKMTGETSCANLINE)
+            GetProcAddress(GetModuleHandle("gdi32.dll"), "D3DKMTGetScanLine");
+
+      while (EnumDisplayDevices(NULL, adapter_index, &add, 0))
+      {
+         HDC hdc = CreateDC(NULL, add.DeviceName, NULL, NULL);
+         if (hdc != NULL)
+         {
+            D3DKMT_OPENADAPTERFROMHDC OpenAdapterData = {0};
+            OpenAdapterData.hDc = hdc;
+            if (pD3DKMTOpenAdapterFromHdc(&OpenAdapterData) == STATUS_SUCCESS)
+            {
+               d3dkmt_adapter_hAdapter      = OpenAdapterData.hAdapter;
+               d3dkmt_adapter_VidPnSourceId = OpenAdapterData.VidPnSourceId;
+            }
+            DeleteDC(hdc);
+
+            if (d3dkmt_adapter_hAdapter)
+               break;
+         }
+         adapter_index++;
+      }
+
+      memset(&d3dkmt_adapter, 0, sizeof(d3dkmt_adapter_t));
+
+      if (pD3DKMTGetScanLine)
+      {
+         D3DKMT_GETSCANLINE sl = {0};
+         sl.hAdapter           = d3dkmt_adapter_hAdapter;
+         sl.VidPnSourceId      = d3dkmt_adapter_VidPnSourceId;
+         d3dkmt_adapter.sl     = sl;
+      }
+   }
+
+   video_driver_scanline_init();
+}
+
+INLINE unsigned d3dkmt_scanline_get(void)
+{
+   if (pD3DKMTGetScanLine)
+   {
+      if (pD3DKMTGetScanLine(&d3dkmt_adapter.sl) == STATUS_SUCCESS)
+         return d3dkmt_adapter.sl.ScanLine;
+   }
+   return 0;
+}
+#endif /* HAVE_D3DKMT */

gfx/common/win32_common.h

@@ -197,6 +197,25 @@ void win32_resources_free(void);
 HACCEL win32_resources_get_accelerator(void);
 #endif /* !__WINRT__ */
 
+#ifdef HAVE_D3DKMT
+typedef LONG NTSTATUS;
+#define STATUS_SUCCESS ((NTSTATUS)0)
+#include <d3dkmthk.h>
+typedef NTSTATUS(CALLBACK* D3DKMTOPENADAPTERFROMHDC)(D3DKMT_OPENADAPTERFROMHDC*);
+static D3DKMTOPENADAPTERFROMHDC pD3DKMTOpenAdapterFromHdc;
+typedef NTSTATUS(CALLBACK* D3DKMTGETSCANLINE)(D3DKMT_GETSCANLINE*);
+static D3DKMTGETSCANLINE pD3DKMTGetScanLine;
+
+typedef struct d3dkmt_adapter
+{
+   D3DKMT_GETSCANLINE sl;
+} d3dkmt_adapter_t;
+
+static d3dkmt_adapter_t d3dkmt_adapter;
+extern void d3dkmt_init(void);
+extern unsigned d3dkmt_scanline_get(void);
+#endif /* HAVE_D3DKMT */
+
 RETRO_END_DECLS
 
 #endif

gfx/drivers/d3d11.c

@@ -3098,6 +3098,7 @@ static bool d3d11_init_swapchain(d3d11_video_t* d3d11,
 #endif    /* __WINRT__ */
 
    if (     (d3d11->flags & D3D11_ST_FLAG_WAITABLE_SWAPCHAINS)
+         && (d3d11->flags & D3D11_ST_FLAG_VSYNC)
          && (d3d11->frameLatencyWaitableObject = DXGIGetFrameLatencyWaitableObject(d3d11->swapChain)))
    {
       settings_t* settings      = config_get_ptr();
@@ -4966,7 +4967,7 @@ static void d3d11_gfx_set_nonblock_state(void* data,
    if (!d3d11)
       return;
 
-   if (toggle)
+   if (toggle || !swap_interval)
       d3d11->flags     &= ~D3D11_ST_FLAG_VSYNC;
    else
       d3d11->flags     |=  D3D11_ST_FLAG_VSYNC;

gfx/drivers/d3d12.c

@@ -3722,6 +3722,7 @@ static bool d3d12_init_swapchain(d3d12_video_t* d3d12,
    }
 
    if (     (d3d12->flags & D3D12_ST_FLAG_WAITABLE_SWAPCHAINS)
+         && (d3d12->flags & D3D12_ST_FLAG_VSYNC)
          && (d3d12->chain.frameLatencyWaitableObject = DXGIGetFrameLatencyWaitableObject(d3d12->chain.handle)))
    {
       settings_t* settings      = config_get_ptr();
@@ -6020,7 +6021,7 @@ static void d3d12_gfx_set_nonblock_state(void* data,
    if (!d3d12)
       return;
 
-   if (toggle)
+   if (toggle || !swap_interval)
       d3d12->flags           &= ~D3D12_ST_FLAG_VSYNC;
    else
       d3d12->flags           |=  D3D12_ST_FLAG_VSYNC;

gfx/drivers/vulkan.c

@@ -5247,7 +5247,7 @@ static void vulkan_set_nonblock_state(void *data, bool state,
    if (vk->ctx_driver->swap_interval)
    {
       int interval             = 0;
-      if (!state)
+      if (!state && swap_interval)
          interval = swap_interval;
       if (adaptive_vsync_enabled && interval == 1)
          interval = -1;