mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-02 07:20:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9591 from Rinnegatamante/videodrivers2

Browse Source 
Graceful switching between videodrivers #2.
This commit is contained in:
Twinaphex 2019-10-15 22:49:17 +02:00 committed by GitHub
commit 4ac264b1d0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 203 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
gfx/common/vulkan_common.c
View File

@ -1651,12 +1651,6 @@ static bool vulkan_context_init_gpu(gfx_ctx_vulkan_data_t *vk)
video_driver_set_gpu_api_devices(GFX_CTX_VULKAN_API, vulkan_gpu_list); video_driver_set_gpu_api_devices(GFX_CTX_VULKAN_API, vulkan_gpu_list);
if (vk->context.gpu != VK_NULL_HANDLE)
{
free(gpus);
return true;
}
if (0 <= settings->ints.vulkan_gpu_index && settings->ints.vulkan_gpu_index < (int)gpu_count) if (0 <= settings->ints.vulkan_gpu_index && settings->ints.vulkan_gpu_index < (int)gpu_count)
{ {
RARCH_LOG("[Vulkan]: Using GPU index %d.\n", settings->ints.vulkan_gpu_index); RARCH_LOG("[Vulkan]: Using GPU index %d.\n", settings->ints.vulkan_gpu_index);
@ -1908,11 +1902,8 @@ static bool vulkan_context_init_device(gfx_ctx_vulkan_data_t *vk)
return false; return false;
} }
if (vk->context.queue == VK_NULL_HANDLE) vkGetDeviceQueue(vk->context.device,
{ vk->context.graphics_queue_index, 0, &vk->context.queue);
vkGetDeviceQueue(vk->context.device,
vk->context.graphics_queue_index, 0, &vk->context.queue);
}
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
vk->context.queue_lock = slock_new(); vk->context.queue_lock = slock_new();
@ -2677,13 +2668,17 @@ void vulkan_context_destroy(gfx_ctx_vulkan_data_t *vk,
else else
{ {
if (vk->context.device) if (vk->context.device)
{
vkDestroyDevice(vk->context.device, NULL); vkDestroyDevice(vk->context.device, NULL);
vk->context.device = NULL;
}
if (vk->context.instance) if (vk->context.instance)
{ {
if (vk->context.destroy_device) if (vk->context.destroy_device)
vk->context.destroy_device(); vk->context.destroy_device();
vkDestroyInstance(vk->context.instance, NULL); vkDestroyInstance(vk->context.instance, NULL);
vk->context.instance = NULL;
if (vulkan_library) if (vulkan_library)
{ {

2
gfx/drivers/vulkan.c
View File

@ -1179,6 +1179,8 @@ static void *vulkan_init(const video_info_t *video,
vk->ctx_driver = ctx_driver; vk->ctx_driver = ctx_driver;
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver); video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
RARCH_LOG("[Vulkan]: Found vulkan context: %s\n", ctx_driver->ident);
video_context_driver_get_video_size(&mode); video_context_driver_get_video_size(&mode);
full_x = mode.width; full_x = mode.width;

374
gfx/drivers_context/x_ctx.c
View File

@ -64,9 +64,9 @@ typedef Bool (*GLXGETMSCRATEOMLPROC)(Display *dpy, GLXDrawable drawable, int3
int32_t *denominator); int32_t *denominator);
typedef int64_t (*GLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable, typedef int64_t (*GLXSWAPBUFFERSMSCOMLPROC)(Display *dpy, GLXDrawable drawable,
int64_t target_msc, int64_t divisor, int64_t target_msc, int64_t divisor,
int64_t remainder); int64_t g_remainder);
typedef Bool (*GLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc, typedef Bool (*GLXWAITFORMSCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_msc,
int64_t divisor, int64_t remainder, int64_t *ust, int64_t divisor, int64_t g_remainder, int64_t *ust,
int64_t *msc, int64_t *sbc); int64_t *msc, int64_t *sbc);
typedef Bool (*GLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc, typedef Bool (*GLXWAITFORSBCOMLPROC)(Display *dpy, GLXDrawable drawable, int64_t target_sbc,
int64_t *ust, int64_t *msc, int64_t *sbc); int64_t *ust, int64_t *msc, int64_t *sbc);
@ -76,38 +76,34 @@ static GLXGETMSCRATEOMLPROC glXGetMscRateOML;
static GLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML; static GLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML;
static GLXWAITFORMSCOMLPROC glXWaitForMscOML; static GLXWAITFORMSCOMLPROC glXWaitForMscOML;
static GLXWAITFORSBCOMLPROC glXWaitForSbcOML; static GLXWAITFORSBCOMLPROC glXWaitForSbcOML;
#endif #endif
typedef struct gfx_ctx_x_data static int64_t ust;
{ static int64_t msc;
int64_t ust; static int64_t sbc;
int64_t msc;
int64_t sbc;
int divisor; static int divisor;
int remainder; static int g_remainder;
bool g_use_hw_ctx; static bool g_use_hw_ctx;
bool g_core_es; static bool g_core_es;
bool g_core_es_core; static bool g_core_es_core;
bool g_debug; static bool g_debug;
bool g_should_reset_mode; static bool g_should_reset_mode;
bool g_is_double; static bool g_is_double;
bool core_hw_context_enable; static bool core_hw_context_enable;
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
GLXWindow g_glx_win; static GLXWindow g_glx_win;
GLXContext g_ctx, g_hw_ctx; static GLXContext g_ctx, g_hw_ctx;
GLXFBConfig g_fbc; static GLXFBConfig g_fbc;
unsigned swap_mode; static unsigned swap_mode;
#endif #endif
int g_interval; static int g_interval;
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
gfx_ctx_vulkan_data_t vk; static gfx_ctx_vulkan_data_t x_vk;
#endif #endif
} gfx_ctx_x_data_t;
static bool x_adaptive_vsync = false; static bool x_adaptive_vsync = false;
static bool x_enable_msaa = false; static bool x_enable_msaa = false;
@ -115,8 +111,6 @@ static unsigned g_major = 0;
static unsigned g_minor = 0; static unsigned g_minor = 0;
static enum gfx_ctx_api x_api = GFX_CTX_NONE; static enum gfx_ctx_api x_api = GFX_CTX_NONE;
static gfx_ctx_x_data_t *current_context_data = NULL;
typedef struct Hints typedef struct Hints
{ {
unsigned long flags; unsigned long flags;
@ -176,6 +170,11 @@ static int GLXExtensionSupported(Display *dpy, const char *extension)
} }
#endif #endif
typedef struct gfx_ctx_cgl_data
{
void *empty;
} gfx_ctx_x_data_t;
static int x_log_error_handler(Display *dpy, XErrorEvent *event) static int x_log_error_handler(Display *dpy, XErrorEvent *event)
{ {
char buf[1024]; char buf[1024];
@ -192,60 +191,58 @@ static int x_nul_handler(Display *dpy, XErrorEvent *event)
return 0; return 0;
} }
static void gfx_ctx_x_destroy_resources(gfx_ctx_x_data_t *x) static void gfx_ctx_x_destroy(void *data)
{ {
x11_input_ctx_destroy(); gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t *)data;
if (g_x11_dpy) switch (x_api)
{ {
switch (x_api) case GFX_CTX_OPENGL_API:
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
if (x->g_ctx) if (g_ctx)
{ {
if (x->swap_mode) if (swap_mode)
glXSwapBuffersMscOML(g_x11_dpy, x->g_glx_win, 0, x->divisor, x->remainder); glXSwapBuffersMscOML(g_x11_dpy, g_glx_win, 0, divisor, g_remainder);
else else
glXSwapBuffers(g_x11_dpy, x->g_glx_win); glXSwapBuffers(g_x11_dpy, g_glx_win);
glFinish(); glFinish();
glXMakeContextCurrent(g_x11_dpy, None, None, NULL); glXMakeContextCurrent(g_x11_dpy, None, None, NULL);
if (!video_driver_is_video_cache_context()) if (!video_driver_is_video_cache_context())
{ {
if (x->g_hw_ctx) if (g_hw_ctx)
glXDestroyContext(g_x11_dpy, x->g_hw_ctx); glXDestroyContext(g_x11_dpy, g_hw_ctx);
if (x->g_ctx) if (g_ctx)
glXDestroyContext(g_x11_dpy, x->g_ctx); glXDestroyContext(g_x11_dpy, g_ctx);
x->g_ctx = NULL; g_ctx = NULL;
x->g_hw_ctx = NULL; g_hw_ctx = NULL;
} }
} }
if (g_x11_win) if (g_x11_win)
{ {
if (x->g_glx_win) if (g_glx_win)
glXDestroyWindow(g_x11_dpy, x->g_glx_win); glXDestroyWindow(g_x11_dpy, g_glx_win);
x->g_glx_win = 0; g_glx_win = 0;
} }
#endif #endif
break; break;
case GFX_CTX_VULKAN_API:
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
vulkan_context_destroy(&x->vk, g_x11_win != 0); vulkan_context_destroy(&x_vk, g_x11_win != 0);
#ifdef HAVE_THREADS
if (x_vk.context.queue_lock)
slock_free(x_vk.context.queue_lock);
#endif #endif
break; #endif
break;
case GFX_CTX_NONE: case GFX_CTX_NONE:
default: default:
break; break;
}
} }
if (g_x11_win && g_x11_dpy) if (g_x11_win && g_x11_dpy)
{ {
#ifdef HAVE_XINERAMA #ifdef HAVE_XINERAMA
@ -259,10 +256,10 @@ static void gfx_ctx_x_destroy_resources(gfx_ctx_x_data_t *x)
if (g_x11_dpy) if (g_x11_dpy)
{ {
if (x->g_should_reset_mode) if (g_should_reset_mode)
{ {
x11_exit_fullscreen(g_x11_dpy); x11_exit_fullscreen(g_x11_dpy);
x->g_should_reset_mode = false; g_should_reset_mode = false;
} }
if (!video_driver_is_video_cache_context()) if (!video_driver_is_video_cache_context())
@ -271,6 +268,9 @@ static void gfx_ctx_x_destroy_resources(gfx_ctx_x_data_t *x)
g_x11_dpy = NULL; g_x11_dpy = NULL;
} }
} }
if (x)
free(x);
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
g_pglSwapInterval = NULL; g_pglSwapInterval = NULL;
@ -279,59 +279,35 @@ static void gfx_ctx_x_destroy_resources(gfx_ctx_x_data_t *x)
#endif #endif
g_major = 0; g_major = 0;
g_minor = 0; g_minor = 0;
x->g_core_es = false; g_core_es = false;
}
static void gfx_ctx_x_destroy(void *data)
{
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data;
if (!x)
return;
gfx_ctx_x_destroy_resources(x);
switch (x_api)
{
case GFX_CTX_VULKAN_API:
#if defined(HAVE_VULKAN) && defined(HAVE_THREADS)
if (x->vk.context.queue_lock)
slock_free(x->vk.context.queue_lock);
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
free(data);
} }
static void gfx_ctx_x_swap_interval(void *data, int interval) static void gfx_ctx_x_swap_interval(void *data, int interval)
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
switch (x_api) switch (x_api)
{ {
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
x->g_interval = interval; g_interval = interval;
if (g_pglSwapIntervalEXT) if (g_pglSwapIntervalEXT)
{ {
RARCH_LOG("[GLX]: glXSwapIntervalEXT(%i)\n", x->g_interval); RARCH_LOG("[GLX]: glXSwapIntervalEXT(%i)\n", g_interval);
g_pglSwapIntervalEXT(g_x11_dpy, x->g_glx_win, x->g_interval); g_pglSwapIntervalEXT(g_x11_dpy, g_glx_win, g_interval);
} }
else if (g_pglSwapInterval) else if (g_pglSwapInterval)
{ {
RARCH_LOG("[GLX]: glXSwapInterval(%i)\n", x->g_interval); RARCH_LOG("[GLX]: glXSwapInterval(%i)\n", g_interval);
if (g_pglSwapInterval(x->g_interval) != 0) if (g_pglSwapInterval(g_interval) != 0)
RARCH_WARN("[GLX]: glXSwapInterval() failed.\n"); RARCH_WARN("[GLX]: glXSwapInterval() failed.\n");
} }
else if (g_pglSwapIntervalSGI) else if (g_pglSwapIntervalSGI)
{ {
RARCH_LOG("[GLX]: glXSwapIntervalSGI(%i)\n", x->g_interval); RARCH_LOG("[GLX]: glXSwapIntervalSGI(%i)\n", g_interval);
if (g_pglSwapIntervalSGI(x->g_interval) != 0) if (g_pglSwapIntervalSGI(g_interval) != 0)
RARCH_WARN("[GLX]: glXSwapIntervalSGI() failed.\n"); RARCH_WARN("[GLX]: glXSwapIntervalSGI() failed.\n");
} }
#endif #endif
@ -339,11 +315,11 @@ static void gfx_ctx_x_swap_interval(void *data, int interval)
case GFX_CTX_VULKAN_API: case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
if (x->g_interval != interval) if (g_interval != interval)
{ {
x->g_interval = interval; g_interval = interval;
if (x->vk.swapchain) if (x_vk.swapchain)
x->vk.need_new_swapchain = true; x_vk.need_new_swapchain = true;
} }
#endif #endif
break; break;
@ -356,39 +332,36 @@ static void gfx_ctx_x_swap_interval(void *data, int interval)
static void gfx_ctx_x_swap_buffers(void *data, void *data2) static void gfx_ctx_x_swap_buffers(void *data, void *data2)
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
switch (x_api) switch (x_api)
{ {
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
if (x->swap_mode) if (swap_mode)
{ {
if (x->g_interval) if (g_interval)
{ {
glXWaitForMscOML(g_x11_dpy, x->g_glx_win, x->msc + x->g_interval, glXWaitForMscOML(g_x11_dpy, g_glx_win, msc + g_interval,
0, 0, &x->ust, &x->msc, &x->sbc); 0, 0, &ust, &msc, &sbc);
glXSwapBuffersMscOML(g_x11_dpy, x->g_glx_win, 0, 0, 0); glXSwapBuffersMscOML(g_x11_dpy, g_glx_win, 0, 0, 0);
} }
else else
glXSwapBuffersMscOML(g_x11_dpy, x->g_glx_win, 0, x->divisor, x->remainder); glXSwapBuffersMscOML(g_x11_dpy, g_glx_win, 0, divisor, g_remainder);
#if 0
RARCH_LOG("UST: %d, MSC: %d, SBC: %d\n", x->ust, x->msc, x->sbc);
#endif
} }
else else
{ {
if (x->g_is_double) if (g_is_double)
glXSwapBuffers(g_x11_dpy, x->g_glx_win); glXSwapBuffers(g_x11_dpy, g_glx_win);
} }
#endif #endif
break; break;
case GFX_CTX_VULKAN_API: case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
vulkan_present(&x->vk, x->vk.context.current_swapchain_index); vulkan_present(&x_vk, x_vk.context.current_swapchain_index);
vulkan_acquire_next_image(&x->vk); vulkan_acquire_next_image(&x_vk);
#endif #endif
break; break;
@ -402,6 +375,7 @@ static void gfx_ctx_x_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, bool *resize, unsigned *width, unsigned *height,
bool is_shutdown) bool is_shutdown)
{ {
(void)data;
x11_check_window(data, quit, resize, width, height, x11_check_window(data, quit, resize, width, height,
is_shutdown); is_shutdown);
@ -410,8 +384,7 @@ static void gfx_ctx_x_check_window(void *data, bool *quit,
case GFX_CTX_VULKAN_API: case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; if (x_vk.need_new_swapchain)
if (x->vk.need_new_swapchain)
*resize = true; *resize = true;
} }
#endif #endif
@ -434,23 +407,16 @@ static bool gfx_ctx_x_set_resize(void *data,
{ {
case GFX_CTX_VULKAN_API: case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
if (!vulkan_create_swapchain(&x_vk, width, height, g_interval))
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; RARCH_ERR("[X/Vulkan]: Failed to update swapchain.\n");
return false;
/* FIXME/TODO - threading error here */
if (!vulkan_create_swapchain(&x->vk, width, height, x->g_interval))
{
RARCH_ERR("[X/Vulkan]: Failed to update swapchain.\n");
x->vk.swapchain = VK_NULL_HANDLE;
return false;
}
if (x->vk.created_new_swapchain)
vulkan_acquire_next_image(&x->vk);
x->vk.context.invalid_swapchain = true;
x->vk.need_new_swapchain = false;
} }
if (x_vk.created_new_swapchain)
vulkan_acquire_next_image(&x_vk);
x_vk.context.invalid_swapchain = true;
x_vk.need_new_swapchain = false;
#endif #endif
break; break;
@ -494,10 +460,8 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
if (!x) if (!x)
return NULL; return NULL;
current_context_data = x;
XInitThreads(); XInitThreads();
if (!x11_connect()) if (!x11_connect())
goto error; goto error;
@ -506,6 +470,7 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGLES) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGLES) || defined(HAVE_OPENGL_CORE)
RARCH_LOG("[TEST] GFX_CTX_OPENGL_API\n");
glXQueryVersion(g_x11_dpy, &major, &minor); glXQueryVersion(g_x11_dpy, &major, &minor);
/* GLX 1.3+ minimum required. */ /* GLX 1.3+ minimum required. */
@ -516,28 +481,32 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB"); glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB");
#ifdef GL_DEBUG #ifdef GL_DEBUG
x->g_debug = true; g_debug = true;
#else #else
x->g_debug = hwr->debug_context; g_debug = hwr->debug_context;
#endif #endif
/* Have to use ContextAttribs */ /* Have to use ContextAttribs */
#ifdef HAVE_OPENGLES2 #ifdef HAVE_OPENGLES2
x->g_core_es = true; g_core_es = true;
x->g_core_es_core = true; g_core_es_core = true;
#else #else
x->g_core_es = (g_major * 1000 + g_minor) >= 3001; g_core_es = (g_major * 1000 + g_minor) >= 3001;
x->g_core_es_core = (g_major * 1000 + g_minor) >= 3002; g_core_es_core = (g_major * 1000 + g_minor) >= 3002;
#endif #endif
if ((x->g_core_es || x->g_debug) && !glx_create_context_attribs) if ((g_core_es || g_debug) && !glx_create_context_attribs)
goto error; goto error;
fbcs = glXChooseFBConfig(g_x11_dpy, DefaultScreen(g_x11_dpy), fbcs = glXChooseFBConfig(g_x11_dpy, DefaultScreen(g_x11_dpy),
visual_attribs, &nelements); visual_attribs, &nelements);
RARCH_LOG("[TEST] fbcs\n");
if (!fbcs) if (!fbcs)
goto error; goto error;
RARCH_LOG("[TEST] nelements\n");
if (!nelements) if (!nelements)
{ {
@ -545,15 +514,17 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
goto error; goto error;
} }
x->g_fbc = fbcs[0]; g_fbc = fbcs[0];
XFree(fbcs); XFree(fbcs);
#endif #endif
break; break;
case GFX_CTX_VULKAN_API: case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
RARCH_LOG("[TEST] GFX_CTX_VULKAN_API\n");
/* Use XCB WSI since it's the most supported WSI over legacy Xlib. */ /* Use XCB WSI since it's the most supported WSI over legacy Xlib. */
if (!vulkan_context_init(&x->vk, VULKAN_WSI_XCB)) if (!vulkan_context_init(&x_vk, VULKAN_WSI_XCB))
goto error; goto error;
RARCH_LOG("[TEST] vulkan_context_init success (vk->context: 0x%08X\n", x_vk.context);
#endif #endif
break; break;
@ -577,7 +548,7 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
{ {
RARCH_LOG("[GLX]: GLX_OML_sync_control and GLX_MESA_swap_control supported, using better swap control method...\n"); RARCH_LOG("[GLX]: GLX_OML_sync_control and GLX_MESA_swap_control supported, using better swap control method...\n");
x->swap_mode = 1; swap_mode = 1;
glXGetSyncValuesOML = (GLXGETSYNCVALUESOMLPROC)glXGetProcAddress((unsigned char *)"glXGetSyncValuesOML"); glXGetSyncValuesOML = (GLXGETSYNCVALUESOMLPROC)glXGetProcAddress((unsigned char *)"glXGetSyncValuesOML");
glXGetMscRateOML = (GLXGETMSCRATEOMLPROC)glXGetProcAddress((unsigned char *)"glXGetMscRateOML"); glXGetMscRateOML = (GLXGETMSCRATEOMLPROC)glXGetProcAddress((unsigned char *)"glXGetMscRateOML");
@ -585,10 +556,10 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
glXWaitForMscOML = (GLXWAITFORMSCOMLPROC)glXGetProcAddress((unsigned char *)"glXWaitForMscOML"); glXWaitForMscOML = (GLXWAITFORMSCOMLPROC)glXGetProcAddress((unsigned char *)"glXWaitForMscOML");
glXWaitForSbcOML = (GLXWAITFORSBCOMLPROC)glXGetProcAddress((unsigned char *)"glXWaitForSbcOML"); glXWaitForSbcOML = (GLXWAITFORSBCOMLPROC)glXGetProcAddress((unsigned char *)"glXWaitForSbcOML");
glXGetSyncValuesOML(g_x11_dpy, g_x11_win, &x->ust, &x->msc, &x->sbc); glXGetSyncValuesOML(g_x11_dpy, g_x11_win, &ust, &msc, &sbc);
#if 0 #if 0
RARCH_LOG("[GLX]: UST: %d, MSC: %d, SBC: %d\n", x->ust, x->msc, x->sbc); RARCH_LOG("[GLX]: UST: %d, MSC: %d, SBC: %d\n", ust, msc, sbc);
#endif #endif
} }
#endif #endif
@ -602,7 +573,6 @@ static void *gfx_ctx_x_init(video_frame_info_t *video_info, void *data)
error: error:
if (x) if (x)
{ {
gfx_ctx_x_destroy_resources(x);
free(x); free(x);
} }
g_x11_screen = 0; g_x11_screen = 0;
@ -644,7 +614,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
vi = glXGetVisualFromFBConfig(g_x11_dpy, x->g_fbc); vi = glXGetVisualFromFBConfig(g_x11_dpy, g_fbc);
if (!vi) if (!vi)
goto error; goto error;
#endif #endif
@ -677,7 +647,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
{ {
if (x11_enter_fullscreen(video_info, g_x11_dpy, width, height)) if (x11_enter_fullscreen(video_info, g_x11_dpy, width, height))
{ {
x->g_should_reset_mode = true; g_should_reset_mode = true;
true_full = true; true_full = true;
} }
else else
@ -767,7 +737,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
x->g_glx_win = glXCreateWindow(g_x11_dpy, x->g_fbc, g_x11_win, 0); g_glx_win = glXCreateWindow(g_x11_dpy, g_fbc, g_x11_win, 0);
#endif #endif
break; break;
@ -821,21 +791,21 @@ static bool gfx_ctx_x_set_video_mode(void *data,
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
if (!x->g_ctx) if (!g_ctx)
{ {
if (x->g_core_es || x->g_debug) if (g_core_es || g_debug)
{ {
int attribs[16] = {0}; int attribs[16] = {0};
int *aptr = attribs; int *aptr = attribs;
if (x->g_core_es) if (g_core_es)
{ {
*aptr++ = GLX_CONTEXT_MAJOR_VERSION_ARB; *aptr++ = GLX_CONTEXT_MAJOR_VERSION_ARB;
*aptr++ = g_major; *aptr++ = g_major;
*aptr++ = GLX_CONTEXT_MINOR_VERSION_ARB; *aptr++ = GLX_CONTEXT_MINOR_VERSION_ARB;
*aptr++ = g_minor; *aptr++ = g_minor;
if (x->g_core_es_core) if (g_core_es_core)
{ {
/* Technically, we don't have core/compat until 3.2. /* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending on * Version 3.1 is either compat or not depending on
@ -850,7 +820,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
} }
} }
if (x->g_debug) if (g_debug)
{ {
*aptr++ = GLX_CONTEXT_FLAGS_ARB; *aptr++ = GLX_CONTEXT_FLAGS_ARB;
*aptr++ = GLX_CONTEXT_DEBUG_BIT_ARB; *aptr++ = GLX_CONTEXT_DEBUG_BIT_ARB;
@ -895,28 +865,28 @@ static bool gfx_ctx_x_set_video_mode(void *data,
* The following code can hopefully be removed in the future: * The following code can hopefully be removed in the future:
*/ */
RARCH_LOG("[GLX]: Creating context for requested version %u.%u.\n", g_major, g_minor); RARCH_LOG("[GLX]: Creating context for requested version %u.%u.\n", g_major, g_minor);
x->g_ctx = glx_create_context_attribs(g_x11_dpy, g_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, NULL, True, attribs); g_fbc, NULL, True, attribs);
if (x->g_ctx) if (g_ctx)
{ {
const char *version; const char *version;
if (x->g_use_hw_ctx) if (g_use_hw_ctx)
{ {
RARCH_LOG("[GLX]: Creating shared HW context.\n"); RARCH_LOG("[GLX]: Creating shared HW context.\n");
x->g_hw_ctx = glx_create_context_attribs(g_x11_dpy, g_hw_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, x->g_ctx, True, attribs); g_fbc, g_ctx, True, attribs);
if (!x->g_hw_ctx) if (!g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n"); RARCH_ERR("[GLX]: Failed to create new shared context.\n");
} }
glXMakeContextCurrent(g_x11_dpy, glXMakeContextCurrent(g_x11_dpy,
x->g_glx_win, x->g_glx_win, x->g_ctx); g_glx_win, g_glx_win, g_ctx);
version = (const char*)glGetString(GL_VERSION); version = (const char*)glGetString(GL_VERSION);
if (strstr(version, " Mesa ") != NULL || !x->g_core_es) if (strstr(version, " Mesa ") != NULL || !g_core_es)
{ {
/* we are done, break switch case */ /* we are done, break switch case */
XSetErrorHandler(old_handler); XSetErrorHandler(old_handler);
@ -924,7 +894,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
} }
glXMakeContextCurrent(g_x11_dpy, None, None, NULL); glXMakeContextCurrent(g_x11_dpy, None, None, NULL);
glXDestroyContext(g_x11_dpy, x->g_ctx); glXDestroyContext(g_x11_dpy, g_ctx);
RARCH_LOG("[GLX]: Not running Mesa, trying higher versions...\n"); RARCH_LOG("[GLX]: Not running Mesa, trying higher versions...\n");
} }
@ -935,14 +905,14 @@ static bool gfx_ctx_x_set_video_mode(void *data,
} }
/* end of Mesa workaround / code to be removed */ /* end of Mesa workaround / code to be removed */
/* only try higher versions when x->g_core_es is true */ /* only try higher versions when g_core_es is true */
if (!x->g_core_es) if (!g_core_es)
version_rows = 1; version_rows = 1;
/* try versions from highest down to requested version */ /* try versions from highest down to requested version */
for (i = 0; i < version_rows; i++) for (i = 0; i < version_rows; i++)
{ {
if (x->g_core_es) if (g_core_es)
{ {
attribs[1] = versions[i][0]; attribs[1] = versions[i][0];
attribs[3] = versions[i][1]; attribs[3] = versions[i][1];
@ -951,18 +921,18 @@ static bool gfx_ctx_x_set_video_mode(void *data,
else else
RARCH_LOG("[GLX]: Creating context for version %u.%u.\n", g_major, g_minor); RARCH_LOG("[GLX]: Creating context for version %u.%u.\n", g_major, g_minor);
x->g_ctx = glx_create_context_attribs(g_x11_dpy, g_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, NULL, True, attribs); g_fbc, NULL, True, attribs);
if (x->g_ctx) if (g_ctx)
{ {
if (x->g_use_hw_ctx) if (g_use_hw_ctx)
{ {
RARCH_LOG("[GLX]: Creating shared HW context.\n"); RARCH_LOG("[GLX]: Creating shared HW context.\n");
x->g_hw_ctx = glx_create_context_attribs(g_x11_dpy, g_hw_ctx = glx_create_context_attribs(g_x11_dpy,
x->g_fbc, x->g_ctx, True, attribs); g_fbc, g_ctx, True, attribs);
if (!x->g_hw_ctx) if (!g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n"); RARCH_ERR("[GLX]: Failed to create new shared context.\n");
} }
@ -980,21 +950,21 @@ static bool gfx_ctx_x_set_video_mode(void *data,
} }
else else
{ {
x->g_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc, g_ctx = glXCreateNewContext(g_x11_dpy, g_fbc,
GLX_RGBA_TYPE, 0, True); GLX_RGBA_TYPE, 0, True);
if (x->g_use_hw_ctx) if (g_use_hw_ctx)
{ {
RARCH_LOG("[GLX]: Creating shared HW context.\n"); RARCH_LOG("[GLX]: Creating shared HW context.\n");
x->g_hw_ctx = glXCreateNewContext(g_x11_dpy, x->g_fbc, g_hw_ctx = glXCreateNewContext(g_x11_dpy, g_fbc,
GLX_RGBA_TYPE, x->g_ctx, True); GLX_RGBA_TYPE, g_ctx, True);
if (!x->g_hw_ctx) if (!g_hw_ctx)
RARCH_ERR("[GLX]: Failed to create new shared context.\n"); RARCH_ERR("[GLX]: Failed to create new shared context.\n");
} }
} }
if (!x->g_ctx) if (!g_ctx)
{ {
RARCH_ERR("[GLX]: Failed to create new context.\n"); RARCH_ERR("[GLX]: Failed to create new context.\n");
goto error; goto error;
@ -1007,7 +977,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
} }
glXMakeContextCurrent(g_x11_dpy, glXMakeContextCurrent(g_x11_dpy,
x->g_glx_win, x->g_glx_win, x->g_ctx); g_glx_win, g_glx_win, g_ctx);
#endif #endif
break; break;
@ -1024,9 +994,9 @@ static bool gfx_ctx_x_set_video_mode(void *data,
/* Use XCB surface since it's the most supported WSI. /* Use XCB surface since it's the most supported WSI.
* We can obtain the XCB connection directly from X11. */ * We can obtain the XCB connection directly from X11. */
if (!vulkan_surface_create(&x->vk, VULKAN_WSI_XCB, if (!vulkan_surface_create(&x_vk, VULKAN_WSI_XCB,
g_x11_dpy, &g_x11_win, g_x11_dpy, &g_x11_win,
width, height, x->g_interval)) width, height, g_interval))
goto error; goto error;
} }
#endif #endif
@ -1047,9 +1017,9 @@ static bool gfx_ctx_x_set_video_mode(void *data,
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
glXGetConfig(g_x11_dpy, vi, GLX_DOUBLEBUFFER, &val); glXGetConfig(g_x11_dpy, vi, GLX_DOUBLEBUFFER, &val);
x->g_is_double = val; g_is_double = val;
if (x->g_is_double) if (g_is_double)
{ {
const char *swap_func = NULL; const char *swap_func = NULL;
@ -1082,7 +1052,7 @@ static bool gfx_ctx_x_set_video_mode(void *data,
break; break;
} }
gfx_ctx_x_swap_interval(data, x->g_interval); gfx_ctx_x_swap_interval(data, g_interval);
/* This can blow up on some drivers. /* This can blow up on some drivers.
* It's not fatal, so override errors for this call. */ * It's not fatal, so override errors for this call. */
@ -1103,8 +1073,6 @@ error:
if (vi) if (vi)
XFree(vi); XFree(vi);
gfx_ctx_x_destroy_resources(x);
if (x) if (x)
free(x); free(x);
g_x11_screen = 0; g_x11_screen = 0;
@ -1228,21 +1196,18 @@ static void gfx_ctx_x_show_mouse(void *data, bool state)
static void gfx_ctx_x_bind_hw_render(void *data, bool enable) static void gfx_ctx_x_bind_hw_render(void *data, bool enable)
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
if (!x)
return;
switch (x_api) switch (x_api)
{ {
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API: case GFX_CTX_OPENGL_ES_API:
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE) #if defined(HAVE_OPENGL) || defined(HAVE_OPENGL1) || defined(HAVE_OPENGL_CORE)
x->g_use_hw_ctx = enable; g_use_hw_ctx = enable;
if (!g_x11_dpy || !x->g_glx_win) if (!g_x11_dpy || !g_glx_win)
return; return;
glXMakeContextCurrent(g_x11_dpy, x->g_glx_win, glXMakeContextCurrent(g_x11_dpy, g_glx_win,
x->g_glx_win, enable ? x->g_hw_ctx : x->g_ctx); g_glx_win, enable ? g_hw_ctx : g_ctx);
#endif #endif
break; break;
@ -1255,15 +1220,15 @@ static void gfx_ctx_x_bind_hw_render(void *data, bool enable)
#ifdef HAVE_VULKAN #ifdef HAVE_VULKAN
static void *gfx_ctx_x_get_context_data(void *data) static void *gfx_ctx_x_get_context_data(void *data)
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
return &x->vk.context; return &x_vk.context;
} }
#endif #endif
static uint32_t gfx_ctx_x_get_flags(void *data) static uint32_t gfx_ctx_x_get_flags(void *data)
{ {
uint32_t flags = 0; uint32_t flags = 0;
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
switch (x_api) switch (x_api)
{ {
@ -1272,7 +1237,7 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
if (x_adaptive_vsync) if (x_adaptive_vsync)
BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC); BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);
if (x->core_hw_context_enable || x->g_core_es) if (core_hw_context_enable || g_core_es)
BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT); BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
if (x_enable_msaa) if (x_enable_msaa)
@ -1288,7 +1253,7 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
else else
{ {
#ifdef HAVE_CG #ifdef HAVE_CG
if (!(x->core_hw_context_enable || x->g_core_es)) if (!(core_hw_context_enable || g_core_es))
BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG); BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);
#endif #endif
#ifdef HAVE_GLSL #ifdef HAVE_GLSL
@ -1311,7 +1276,7 @@ static uint32_t gfx_ctx_x_get_flags(void *data)
static void gfx_ctx_x_set_flags(void *data, uint32_t flags) static void gfx_ctx_x_set_flags(void *data, uint32_t flags)
{ {
gfx_ctx_x_data_t *x = (gfx_ctx_x_data_t*)data; (void)data;
switch (x_api) switch (x_api)
{ {
@ -1320,7 +1285,7 @@ static void gfx_ctx_x_set_flags(void *data, uint32_t flags)
if (BIT32_GET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC)) if (BIT32_GET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC))
x_adaptive_vsync = true; x_adaptive_vsync = true;
if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT)) if (BIT32_GET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
x->core_hw_context_enable = true; core_hw_context_enable = true;
if (BIT32_GET(flags, GFX_CTX_FLAGS_MULTISAMPLING)) if (BIT32_GET(flags, GFX_CTX_FLAGS_MULTISAMPLING))
x_enable_msaa = true; x_enable_msaa = true;
break; break;
@ -1332,9 +1297,6 @@ static void gfx_ctx_x_set_flags(void *data, uint32_t flags)
static void gfx_ctx_x_make_current(bool release) static void gfx_ctx_x_make_current(bool release)
{ {
if (!current_context_data)
return;
switch (x_api) switch (x_api)
{ {
case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_API:
@ -1343,9 +1305,7 @@ static void gfx_ctx_x_make_current(bool release)
if (release) if (release)
glXMakeContextCurrent(g_x11_dpy, None, None, NULL); glXMakeContextCurrent(g_x11_dpy, None, None, NULL);
else else
glXMakeContextCurrent(g_x11_dpy, glXMakeContextCurrent(g_x11_dpy, g_glx_win, g_glx_win, g_ctx);
current_context_data->g_glx_win,
current_context_data->g_glx_win, current_context_data->g_ctx);
#endif #endif
break; break;

10
libretro-common/include/libretro.h
View File

@ -1248,6 +1248,16 @@ enum retro_mod
* default when calling SET_VARIABLES/SET_CORE_OPTIONS. * default when calling SET_VARIABLES/SET_CORE_OPTIONS.
*/ */
#define RETRO_ENVIRONMENT_GET_PREFERRED_HW_RENDER 56
/* unsigned * --
*
* Allows an implementation to ask frontend preferred hardware
* context to use. Core should use this information to deal
* with what specific context to request with SET_HW_RENDER.
*
* 'data' points to an unsigned variable
*/
/* VFS functionality */ /* VFS functionality */
/* File paths: /* File paths:

19
retroarch.c
View File

@ -7833,6 +7833,24 @@ static bool rarch_environment_cb(unsigned cmd, void *data)
system->disk_control_cb = system->disk_control_cb =
*(const struct retro_disk_control_callback*)data; *(const struct retro_disk_control_callback*)data;
break; break;
case RETRO_ENVIRONMENT_GET_PREFERRED_HW_RENDER:
{
unsigned *cb = (unsigned*)data;
settings_t *settings = configuration_settings;
RARCH_LOG("[Environ]: GET_PREFERRED_HW_RENDER.\n");
if (!strcmp(settings->arrays.video_driver, "glcore"))
*cb = RETRO_HW_CONTEXT_OPENGL_CORE;
else if (!strcmp(settings->arrays.video_driver, "gl"))
*cb = RETRO_HW_CONTEXT_OPENGL;
else if (!strcmp(settings->arrays.video_driver, "vulkan"))
*cb = RETRO_HW_CONTEXT_VULKAN;
else if (!strncmp(settings->arrays.video_driver, "d3d", 3))
*cb = RETRO_HW_CONTEXT_DIRECT3D;
else
*cb = RETRO_HW_CONTEXT_NONE;
break;
}
case RETRO_ENVIRONMENT_SET_HW_RENDER: case RETRO_ENVIRONMENT_SET_HW_RENDER:
case RETRO_ENVIRONMENT_SET_HW_RENDER | RETRO_ENVIRONMENT_EXPERIMENTAL: case RETRO_ENVIRONMENT_SET_HW_RENDER | RETRO_ENVIRONMENT_EXPERIMENTAL:
@ -7880,7 +7898,6 @@ static bool rarch_environment_cb(unsigned cmd, void *data)
break; break;
} }
case RETRO_ENVIRONMENT_GET_LIBRETRO_PATH: case RETRO_ENVIRONMENT_GET_LIBRETRO_PATH:
{ {
const char **path = (const char**)data; const char **path = (const char**)data;