diff --git a/gfx/drivers/gl.c b/gfx/drivers/gl.c
index 916fea6cfd..e42c8cef1c 100644
--- a/gfx/drivers/gl.c
+++ b/gfx/drivers/gl.c
@@ -3228,7 +3228,14 @@ static void gl2_set_nonblock_state(void *data, bool state)
    if (!state)
       interval = settings->uints.video_swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (gl->ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      gl->ctx_driver->swap_interval(gl->ctx_data, interval);
+   }
    gl2_context_bind_hw_render(gl, true);
 }
 
@@ -3620,7 +3627,14 @@ static void *gl2_init(const video_info_t *video,
    if (video->vsync)
       interval = video->swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (gl->ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video->adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      gl->ctx_driver->swap_interval(gl->ctx_data, interval);
+   }
 
    win_width   = video->width;
    win_height  = video->height;
diff --git a/gfx/drivers/gl1.c b/gfx/drivers/gl1.c
index 324bdf4c98..4fae9689ae 100644
--- a/gfx/drivers/gl1.c
+++ b/gfx/drivers/gl1.c
@@ -309,7 +309,14 @@ static void *gl1_gfx_init(const video_info_t *video,
 
    interval = video->swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video->adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      ctx_driver->swap_interval(gl1->ctx_data, interval);
+   }
 
    if (!video_context_driver_set_video_mode(&mode))
       goto error;
@@ -905,7 +912,14 @@ static void gl1_gfx_set_nonblock_state(void *data, bool state)
    if (!state)
       interval = settings->uints.video_swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (gl1->ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      gl1->ctx_driver->swap_interval(gl1->ctx_data, interval);
+   }
    gl1_context_bind_hw_render(gl1, true);
 }
 
diff --git a/gfx/drivers/gl_core.c b/gfx/drivers/gl_core.c
index 75023f1771..72aa6f17a8 100644
--- a/gfx/drivers/gl_core.c
+++ b/gfx/drivers/gl_core.c
@@ -985,7 +985,14 @@ static void *gl_core_init(const video_info_t *video,
    if (video->vsync)
       interval = video->swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (gl->ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video->adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      gl->ctx_driver->swap_interval(gl->ctx_data, interval);
+   }
 
    win_width   = video->width;
    win_height  = video->height;
@@ -1370,7 +1377,16 @@ static void gl_core_set_nonblock_state(void *data, bool state)
    if (!state)
       interval = settings->uints.video_swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (gl->ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.
+         video_adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      gl->ctx_driver->swap_interval(gl->ctx_data, interval);
+   }
+
    gl_core_context_bind_hw_render(gl, true);
 }
 
diff --git a/gfx/drivers/vg.c b/gfx/drivers/vg.c
index e4690d566a..edc373ffbe 100644
--- a/gfx/drivers/vg.c
+++ b/gfx/drivers/vg.c
@@ -79,8 +79,18 @@ static PFNVGCREATEEGLIMAGETARGETKHRPROC pvgCreateEGLImageTargetKHR;
 
 static void vg_set_nonblock_state(void *data, bool state)
 {
+   vg_t *vg     = (vg_t*)data;
    int interval = state ? 0 : 1;
-   video_context_driver_swap_interval(&interval);
+
+   if (vg->ctx_driver && vg->ctx_driver->swap_interval)
+   {
+      settings_t *settings                   = config_get_ptr();
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      vg->ctx_driver->swap_interval(vg->ctx_data, interval);
+   }
 }
 
 static INLINE bool vg_query_extension(const char *ext)
@@ -134,7 +144,14 @@ static void *vg_init(const video_info_t *video,
 
    interval = video->vsync ? 1 : 0;
 
-   video_context_driver_swap_interval(&interval);
+   if (ctx->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video->adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      ctx->swap_interval(vg->ctx_data, interval);
+   }
 
    vg->mTexType    = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
    vg->keep_aspect = video->force_aspect;
diff --git a/gfx/drivers/vulkan.c b/gfx/drivers/vulkan.c
index b3a3707535..62af257e71 100644
--- a/gfx/drivers/vulkan.c
+++ b/gfx/drivers/vulkan.c
@@ -1188,7 +1188,15 @@ static void *vulkan_init(const video_info_t *video,
 
    RARCH_LOG("[Vulkan]: Detecting screen resolution %ux%u.\n", full_x, full_y);
    interval = video->vsync ? video->swap_interval : 0;
-   video_context_driver_swap_interval(&interval);
+
+   if (ctx_driver->swap_interval)
+   {
+      bool adaptive_vsync_enabled            = video_driver_test_all_flags(
+            GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && video->adaptive_vsync;
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      ctx_driver->swap_interval(vk->ctx_data, interval);
+   }
 
    win_width  = video->width;
    win_height = video->height;
@@ -1298,9 +1306,11 @@ static void vulkan_check_swapchain(vk_t *vk)
 
 static void vulkan_set_nonblock_state(void *data, bool state)
 {
-   int interval         = 0;
-   vk_t *vk             = (vk_t*)data;
-   settings_t *settings = config_get_ptr();
+   int interval                = 0;
+   vk_t *vk                    = (vk_t*)data;
+   settings_t *settings        = config_get_ptr();
+   bool adaptive_vsync_enabled = video_driver_test_all_flags(
+         GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
 
    if (!vk)
       return;
@@ -1310,7 +1320,12 @@ static void vulkan_set_nonblock_state(void *data, bool state)
    if (!state)
       interval = settings->uints.video_swap_interval;
 
-   video_context_driver_swap_interval(&interval);
+   if (vk->ctx_driver->swap_interval)
+   {
+      if (adaptive_vsync_enabled && interval == 1)
+         interval = -1;
+      vk->ctx_driver->swap_interval(vk->ctx_data, interval);
+   }
 
    /* Changing vsync might require recreating the swapchain, which means new VkImages
     * to render into. */
diff --git a/retroarch.c b/retroarch.c
index cc551e2827..a835836178 100644
--- a/retroarch.c
+++ b/retroarch.c
@@ -17830,7 +17830,8 @@ static bool video_driver_init_internal(bool *video_is_threaded)
    video.vsync         = settings->bools.video_vsync && !runloop_force_nonblock;
    video.force_aspect  = settings->bools.video_force_aspect;
    video.font_enable   = settings->bools.video_font_enable;
-   video.swap_interval = settings->uints.video_swap_interval;
+   video.swap_interval  = settings->uints.video_swap_interval;
+   video.adaptive_vsync = settings->bools.video_adaptive_vsync;
 #ifdef GEKKO
    video.viwidth       = settings->uints.video_viwidth;
    video.vfilter       = settings->bools.video_vfilter;
@@ -19644,21 +19645,6 @@ bool video_context_driver_get_video_output_size(gfx_ctx_size_t *size_data)
    return true;
 }
 
-bool video_context_driver_swap_interval(int *interval)
-{
-   int current_interval                   = *interval;
-   settings_t *settings                   = configuration_settings;
-   bool adaptive_vsync_enabled            = video_driver_test_all_flags(
-         GFX_CTX_FLAGS_ADAPTIVE_VSYNC) && settings->bools.video_adaptive_vsync;
-
-   if (!current_video_context.swap_interval)
-      return false;
-   if (adaptive_vsync_enabled && current_interval == 1)
-      current_interval = -1;
-   current_video_context.swap_interval(video_context_data, current_interval);
-   return true;
-}
-
 bool video_context_driver_get_proc_address(gfx_ctx_proc_address_t *proc)
 {
    if (!current_video_context.get_proc_address)
diff --git a/retroarch.h b/retroarch.h
index 3db197d99b..b6775b64c7 100644
--- a/retroarch.h
+++ b/retroarch.h
@@ -1094,6 +1094,8 @@ typedef struct video_info
 
    int swap_interval;
 
+   bool adaptive_vsync;
+
 #ifdef GEKKO
    bool vfilter;
 #endif
@@ -1857,8 +1859,6 @@ void video_context_driver_destroy(void);
 
 bool video_context_driver_get_video_output_size(gfx_ctx_size_t *size_data);
 
-bool video_context_driver_swap_interval(int *interval);
-
 bool video_context_driver_get_proc_address(gfx_ctx_proc_address_t *proc);
 
 bool video_context_driver_suppress_screensaver(bool *bool_data);