mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-20 10:20:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2542 from heuripedes/master

Browse Source 
Context driver improvements
This commit is contained in:
Twinaphex 2015-12-08 19:51:16 +01:00
commit 8144fd0d92
23 changed files with 531 additions and 537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
gfx/common/egl_common.c
View File

@ -23,16 +23,11 @@
#endif
volatile sig_atomic_t g_egl_quit;
EGLContext g_egl_ctx;
EGLContext g_egl_hw_ctx;
EGLSurface g_egl_surf;
EGLDisplay g_egl_dpy;
EGLConfig g_egl_config;
enum gfx_ctx_api g_egl_api;
bool g_egl_inited;
static bool g_egl_use_hw_ctx;
unsigned g_interval;
enum gfx_ctx_api g_egl_api;
unsigned g_egl_major = 0;
unsigned g_egl_minor = 0;
void egl_report_error(void)
{
@ -79,11 +74,12 @@ gfx_ctx_proc_t egl_get_proc_address(const char *symbol)
void egl_destroy(void *data)
{
if (g_egl_dpy)
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
if (egl->dpy)
{
#if defined HAVE_OPENGL
#if !defined(RARCH_MOBILE)
if (g_egl_ctx != EGL_NO_CONTEXT)
if (egl->ctx != EGL_NO_CONTEXT)
{
glFlush();
glFinish();
@ -91,71 +87,74 @@ void egl_destroy(void *data)
#endif
#endif
eglMakeCurrent(g_egl_dpy,
eglMakeCurrent(egl->dpy,
EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (g_egl_ctx != EGL_NO_CONTEXT)
eglDestroyContext(g_egl_dpy, g_egl_ctx);
if (egl->ctx != EGL_NO_CONTEXT)
eglDestroyContext(egl->dpy, egl->ctx);
if (g_egl_hw_ctx != EGL_NO_CONTEXT)
eglDestroyContext(g_egl_dpy, g_egl_hw_ctx);
if (egl->hw_ctx != EGL_NO_CONTEXT)
eglDestroyContext(egl->dpy, egl->hw_ctx);
if (g_egl_surf != EGL_NO_SURFACE)
eglDestroySurface(g_egl_dpy, g_egl_surf);
eglTerminate(g_egl_dpy);
if (egl->surf != EGL_NO_SURFACE)
eglDestroySurface(egl->dpy, egl->surf);
eglTerminate(egl->dpy);
}
/* Be as careful as possible in deinit.
* If we screw up, any TTY will not restore.
*/
g_egl_ctx = EGL_NO_CONTEXT;
g_egl_hw_ctx = EGL_NO_CONTEXT;
g_egl_surf = EGL_NO_SURFACE;
g_egl_dpy = EGL_NO_DISPLAY;
g_egl_config = 0;
egl->ctx = EGL_NO_CONTEXT;
egl->hw_ctx = EGL_NO_CONTEXT;
egl->surf = EGL_NO_SURFACE;
egl->dpy = EGL_NO_DISPLAY;
egl->config = 0;
g_egl_quit = 0;
g_egl_api = GFX_CTX_NONE;
egl->api = GFX_CTX_NONE;
g_egl_inited = false;
}
void egl_bind_hw_render(void *data, bool enable)
{
g_egl_use_hw_ctx = enable;
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
egl->use_hw_ctx = enable;
if (g_egl_dpy == EGL_NO_DISPLAY)
if (egl->dpy == EGL_NO_DISPLAY)
return;
if (g_egl_surf == EGL_NO_SURFACE)
if (egl->surf == EGL_NO_SURFACE)
return;
eglMakeCurrent(g_egl_dpy, g_egl_surf,
g_egl_surf,
enable ? g_egl_hw_ctx : g_egl_ctx);
eglMakeCurrent(egl->dpy, egl->surf,
egl->surf,
enable ? egl->hw_ctx : egl->ctx);
}
void egl_swap_buffers(void *data)
{
if (g_egl_dpy == EGL_NO_DISPLAY)
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
if (egl->dpy == EGL_NO_DISPLAY)
return;
if (g_egl_surf == EGL_NO_SURFACE)
if (egl->surf == EGL_NO_SURFACE)
return;
eglSwapBuffers(g_egl_dpy, g_egl_surf);
eglSwapBuffers(egl->dpy, egl->surf);
}
void egl_set_swap_interval(void *data, unsigned interval)
{
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
/* Can be called before initialization.
* Some contexts require that swap interval
* is known at startup time.
*/
g_interval = interval;
egl->interval = interval;
if (g_egl_dpy == EGL_NO_DISPLAY)
if (egl->dpy == EGL_NO_DISPLAY)
return;
if (!(eglGetCurrentContext()))
return;
RARCH_LOG("[EGL]: eglSwapInterval(%u)\n", interval);
if (!eglSwapInterval(g_egl_dpy, interval))
if (!eglSwapInterval(egl->dpy, interval))
{
RARCH_ERR("[EGL]: eglSwapInterval() failed.\n");
egl_report_error();
@ -164,15 +163,17 @@ void egl_set_swap_interval(void *data, unsigned interval)
void egl_get_video_size(void *data, unsigned *width, unsigned *height)
{
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
*width = 0;
*height = 0;
if (g_egl_dpy != EGL_NO_DISPLAY && g_egl_surf != EGL_NO_SURFACE)
if (egl->dpy != EGL_NO_DISPLAY && egl->surf != EGL_NO_SURFACE)
{
EGLint gl_width, gl_height;
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_WIDTH, &gl_width);
eglQuerySurface(g_egl_dpy, g_egl_surf, EGL_HEIGHT, &gl_height);
eglQuerySurface(egl->dpy, egl->surf, EGL_WIDTH, &gl_width);
eglQuerySurface(egl->dpy, egl->surf, EGL_HEIGHT, &gl_height);
*width = gl_width;
*height = gl_height;
}
@ -196,59 +197,66 @@ void egl_install_sighandlers(void)
sigaction(SIGTERM, &sa, NULL);
}
bool egl_init_context(NativeDisplayType display,
bool egl_init_context(void *data, NativeDisplayType display,
EGLint *major, EGLint *minor,
EGLint *n, const EGLint *attrib_ptr)
{
g_egl_dpy = eglGetDisplay(display);
if (!g_egl_dpy)
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
egl->dpy = eglGetDisplay(display);
if (!egl->dpy)
{
RARCH_ERR("[EGL]: Couldn't get EGL display.\n");
return false;
}
if (!eglInitialize(g_egl_dpy, major, minor))
if (!eglInitialize(egl->dpy, major, minor))
return false;
RARCH_LOG("[EGL]: EGL version: %d.%d\n", *major, *minor);
if (!eglChooseConfig(g_egl_dpy, attrib_ptr, &g_egl_config, 1, n) || *n != 1)
if (!eglChooseConfig(egl->dpy, attrib_ptr, &egl->config, 1, n) || *n != 1)
return false;
egl->api = g_egl_api;
egl->major = g_egl_major;
egl->minor = g_egl_minor;
return true;
}
bool egl_create_context(EGLint *egl_attribs)
bool egl_create_context(void *data, EGLint *egl_attribs)
{
g_egl_ctx = eglCreateContext(g_egl_dpy, g_egl_config, EGL_NO_CONTEXT,
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
egl->ctx = eglCreateContext(egl->dpy, egl->config, EGL_NO_CONTEXT,
egl_attribs);
g_egl_hw_ctx = NULL;
egl->hw_ctx = NULL;
if (g_egl_ctx == EGL_NO_CONTEXT)
if (egl->ctx == EGL_NO_CONTEXT)
return false;
if (g_egl_use_hw_ctx)
if (egl->use_hw_ctx)
{
g_egl_hw_ctx = eglCreateContext(g_egl_dpy, g_egl_config, g_egl_ctx,
egl->hw_ctx = eglCreateContext(egl->dpy, egl->config, egl->ctx,
egl_attribs);
RARCH_LOG("[EGL]: Created shared context: %p.\n", (void*)g_egl_hw_ctx);
RARCH_LOG("[EGL]: Created shared context: %p.\n", (void*)egl->hw_ctx);
if (g_egl_hw_ctx == EGL_NO_CONTEXT)
if (egl->hw_ctx == EGL_NO_CONTEXT)
return false;;
}
return true;
}
bool egl_create_surface(NativeWindowType native_window)
bool egl_create_surface(void *data, NativeWindowType native_window)
{
g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_egl_config, native_window, NULL);
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
egl->surf = eglCreateWindowSurface(egl->dpy, egl->config, native_window, NULL);
if (g_egl_surf == EGL_NO_SURFACE)
if (egl->surf == EGL_NO_SURFACE)
return false;
/* Connect the context to the surface. */
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
if (!eglMakeCurrent(egl->dpy, egl->surf, egl->surf, egl->ctx))
return false;
RARCH_LOG("[EGL]: Current context: %p.\n", (void*)eglGetCurrentContext());
@ -256,9 +264,10 @@ bool egl_create_surface(NativeWindowType native_window)
return true;
}
bool egl_get_native_visual_id(EGLint *value)
bool egl_get_native_visual_id(void *data, EGLint *value)
{
if (!eglGetConfigAttrib(g_egl_dpy, g_egl_config,
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
if (!eglGetConfigAttrib(egl->dpy, egl->config,
EGL_NATIVE_VISUAL_ID, value))
{
RARCH_ERR("[EGL]: egl_get_native_visual_id failed.\n");
@ -268,9 +277,10 @@ bool egl_get_native_visual_id(EGLint *value)
return true;
}
bool egl_has_config(void)
bool egl_has_config(void *data)
{
if (!g_egl_config)
egl_ctx_data_t *egl = (egl_ctx_data_t*)data;
if (!egl->config)
{
RARCH_ERR("[EGL]: No EGL configurations available.\n");
return false;

54
gfx/common/egl_common.h
View File

@ -29,16 +29,44 @@
extern "C" {
#endif
extern volatile sig_atomic_t g_egl_quit;
/* Put this structure as the first member of egl-based contexts
* like this:
* typedef struct
* {
* egl_ctx_data_t egl;
* int member0;
* char member1;
* ....
* } my_ctx_data_t;
*
* You can call egl functions passing the data pointer you receive
* or using &ctx_data->egl. It's up to you.
*/
typedef struct
{
EGLContext ctx;
EGLContext hw_ctx;
EGLSurface surf;
EGLDisplay dpy;
EGLConfig config;
unsigned interval;
extern EGLContext g_egl_ctx;
extern EGLContext g_egl_hw_ctx;
extern EGLSurface g_egl_surf;
extern EGLDisplay g_egl_dpy;
extern EGLConfig g_egl_config;
extern enum gfx_ctx_api g_egl_api;
unsigned major;
unsigned minor;
enum gfx_ctx_api api;
/* egl "private" */
bool use_hw_ctx;
} egl_ctx_data_t;
extern volatile sig_atomic_t g_egl_quit;
extern bool g_egl_inited;
extern unsigned g_interval;
/* bind_api is called before init so we need these, please
* try no to use them outside of bind_api() and init() */
extern enum gfx_ctx_api g_egl_api;
extern unsigned g_egl_major;
extern unsigned g_egl_minor;
void egl_report_error(void);
@ -56,17 +84,17 @@ void egl_get_video_size(void *data, unsigned *width, unsigned *height);
void egl_install_sighandlers(void);
bool egl_init_context(NativeDisplayType display,
bool egl_init_context(void *data, NativeDisplayType display,
EGLint *major, EGLint *minor,
EGLint *n, const EGLint *attrib_ptr);
bool egl_create_context(EGLint *egl_attribs);
bool egl_create_context(void *data, EGLint *egl_attribs);
bool egl_create_surface(NativeWindowType native_window);
bool egl_create_surface(void *data, NativeWindowType native_window);
bool egl_get_native_visual_id(EGLint *value);
bool egl_get_native_visual_id(void *data, EGLint *value);
bool egl_has_config(void);
bool egl_has_config(void *data);
#ifdef __cplusplus
}

46
gfx/drivers/gl.c
View File

@ -108,7 +108,7 @@ static const GLfloat white_color[] = {
static INLINE void context_bind_hw_render(gl_t *gl, bool enable)
{
if (gl && gl->shared_context_use)
gfx_ctx_bind_hw_render(gl, enable);
gfx_ctx_bind_hw_render(enable);
}
static INLINE bool gl_query_extension(gl_t *gl, const char *ext)
@ -851,7 +851,7 @@ static void gl_set_viewport(void *data, unsigned viewport_width,
video_driver_get_size(&width, &height);
gfx_ctx_translate_aspect(gl, &device_aspect,
gfx_ctx_translate_aspect(&device_aspect,
viewport_width, viewport_height);
if (settings->video.scale_integer && !force_full)
@ -951,7 +951,7 @@ static void gl_set_rotation(void *data, unsigned rotation)
static void gl_set_video_mode(void *data, unsigned width, unsigned height,
bool fullscreen)
{
gfx_ctx_set_video_mode(data, width, height, fullscreen);
gfx_ctx_set_video_mode(width, height, fullscreen);
}
#ifdef HAVE_FBO
@ -1680,7 +1680,7 @@ static bool gl_frame(void *data, const void *frame,
{
gl->should_resize = false;
gfx_ctx_set_resize(gl, width, height);
gfx_ctx_set_resize(width, height);
#ifdef HAVE_FBO
if (gl->fbo_inited)
@ -1809,7 +1809,7 @@ static bool gl_frame(void *data, const void *frame,
gl_render_overlay(gl);
#endif
gfx_ctx_update_window_title(gl);
gfx_ctx_update_window_title();
retro_perf_stop(&frame_run);
@ -1856,11 +1856,11 @@ static bool gl_frame(void *data, const void *frame,
&& !input_driver_ctl(RARCH_INPUT_CTL_IS_NONBLOCK_STATE, NULL)
&& !is_slowmotion && !is_paused)
{
gfx_ctx_swap_buffers(gl);
gfx_ctx_swap_buffers();
glClear(GL_COLOR_BUFFER_BIT);
}
gfx_ctx_swap_buffers(gl);
gfx_ctx_swap_buffers();
#ifdef HAVE_GL_SYNC
if (settings->video.hard_sync && gl->have_sync)
@ -1987,7 +1987,7 @@ static void gl_free(void *data)
}
#endif
gfx_ctx_free(gl);
gfx_ctx_free();
free(gl->empty_buf);
free(gl->conv_buffer);
@ -2005,7 +2005,7 @@ static void gl_set_nonblock_state(void *data, bool state)
RARCH_LOG("[GL]: VSync => %s\n", state ? "off" : "on");
context_bind_hw_render(gl, false);
gfx_ctx_swap_interval(gl,
gfx_ctx_swap_interval(
state ? 0 : settings->video.swap_interval);
context_bind_hw_render(gl, true);
}
@ -2467,10 +2467,10 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
RARCH_LOG("Found GL context: %s\n", ctx_driver->ident);
gfx_ctx_get_video_size(gl, &gl->full_x, &gl->full_y);
gfx_ctx_get_video_size(&gl->full_x, &gl->full_y);
RARCH_LOG("Detecting screen resolution %ux%u.\n", gl->full_x, gl->full_y);
gfx_ctx_swap_interval(gl,
gfx_ctx_swap_interval(
video->vsync ? settings->video.swap_interval : 0);
win_width = video->width;
@ -2482,7 +2482,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
win_height = gl->full_y;
}
if (!gfx_ctx_set_video_mode(gl, win_width, win_height, video->fullscreen))
if (!gfx_ctx_set_video_mode(win_width, win_height, video->fullscreen))
goto error;
/* Clear out potential error flags in case we use cached context. */
@ -2513,7 +2513,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
gl->fullscreen = video->fullscreen;
/* Get real known video size, which might have been altered by context. */
gfx_ctx_get_video_size(gl, &temp_width, &temp_height);
gfx_ctx_get_video_size(&temp_width, &temp_height);
if (temp_width != 0 && temp_height != 0)
video_driver_set_size(&temp_width, &temp_height);
@ -2641,7 +2641,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
goto error;
#endif
gfx_ctx_input_driver(gl, input, input_data);
gfx_ctx_input_driver(input, input_data);
if (settings->video.font_enable)
{
@ -2677,7 +2677,7 @@ static bool gl_alive(void *data)
/* Needed because some context drivers don't track their sizes */
video_driver_get_size(&temp_width, &temp_height);
if (gfx_ctx_check_window(data, &quit,
if (gfx_ctx_check_window(&quit,
&resize, &temp_width, &temp_height))
{
if (quit)
@ -2696,17 +2696,17 @@ static bool gl_alive(void *data)
static bool gl_focus(void *data)
{
return gfx_ctx_focus(data);
return gfx_ctx_focus();
}
static bool gl_suppress_screensaver(void *data, bool enable)
{
return gfx_ctx_suppress_screensaver(data, enable);
return gfx_ctx_suppress_screensaver(enable);
}
static bool gl_has_windowed(void *data)
{
return gfx_ctx_has_windowed(data);
return gfx_ctx_has_windowed();
}
static void gl_update_tex_filter_frame(gl_t *gl)
@ -3189,7 +3189,7 @@ static void gl_overlay_enable(void *data, bool state)
gl->overlay_enable = state;
if (gl->fullscreen)
gfx_ctx_show_mouse(gl, state);
gfx_ctx_show_mouse(state);
}
static void gl_overlay_full_screen(void *data, bool enable)
@ -3381,7 +3381,7 @@ static void gl_set_osd_msg(void *data, const char *msg,
static void gl_show_mouse(void *data, bool state)
{
gfx_ctx_show_mouse(data, state);
gfx_ctx_show_mouse(state);
}
static struct video_shader *gl_get_current_shader(void *data)
@ -3393,17 +3393,17 @@ static struct video_shader *gl_get_current_shader(void *data)
static void gl_get_video_output_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_get_video_output_size(data, width, height);
gfx_ctx_get_video_output_size(width, height);
}
static void gl_get_video_output_prev(void *data)
{
gfx_ctx_get_video_output_prev(data);
gfx_ctx_get_video_output_prev();
}
static void gl_get_video_output_next(void *data)
{
gfx_ctx_get_video_output_next(data);
gfx_ctx_get_video_output_next();
}
static const video_poke_interface_t gl_poke_interface = {

36
gfx/drivers_context/androidegl_ctx.c
View File

@ -32,7 +32,7 @@ int system_property_get(const char *cmd, const char *args, char *value);
static bool g_es3;
static bool android_gfx_ctx_init(void *data)
static void *android_gfx_ctx_init(void *video_driver)
{
EGLint n, major, minor;
EGLint format;
@ -50,39 +50,55 @@ static bool android_gfx_ctx_init(void *data)
EGL_NONE
};
struct android_app *android_app = (struct android_app*)g_android;
egl_ctx_data_t *egl;
if (!android_app)
return false;
egl = (egl_ctx_data_t*)calloc(1, sizeof(*egl));
RARCH_LOG("Android EGL: GLES version = %d.\n", g_es3 ? 3 : 2);
if (!egl_init_context(EGL_DEFAULT_DISPLAY,
if (!egl_init_context(egl, EGL_DEFAULT_DISPLAY,
&major, &minor, &n, attribs))
{
egl_report_error();
goto error;
}
if (!egl_get_native_visual_id(&format))
if (!egl_get_native_visual_id(egl, &format))
goto error;
ANativeWindow_setBuffersGeometry(android_app->window, 0, 0, format);
if (!egl_create_context(context_attributes))
if (!egl_create_context(egl, context_attributes))
{
egl_report_error();
goto error;
}
if (!egl_create_surface(android_app->window))
if (!egl_create_surface(egl, android_app->window))
goto error;
return true;
return egl;
error:
egl_destroy(NULL);
if (egl)
{
egl_destroy(egl);
free(egl);
}
return false;
return NULL;
}
static void android_gfx_ctx_destroy(void *data)
{
if (data)
{
egl_destroy(data);
free(data);
}
}
static void android_gfx_ctx_check_window(void *data, bool *quit,
@ -229,7 +245,7 @@ static bool android_gfx_ctx_get_metrics(void *data,
const gfx_ctx_driver_t gfx_ctx_android = {
android_gfx_ctx_init,
egl_destroy,
android_gfx_ctx_destroy,
android_gfx_ctx_bind_api,
egl_set_swap_interval,
android_gfx_ctx_set_video_mode,

56
gfx/drivers_context/bbqnx_ctx.c
View File

@ -34,20 +34,24 @@
#define WINDOW_BUFFERS 2
static bool g_resize;
screen_context_t screen_ctx;
screen_window_t screen_win;
static screen_display_t screen_disp;
typedef struct {
screen_window_t screen_win;
screen_display_t screen_disp;
bool resize;
} qnx_ctx_data_t;
static void gfx_ctx_qnx_destroy(void *data)
{
qnx_ctx_data_t *qnx = (qnx_ctx_data_t*)data;
egl_destroy(data);
g_resize = false;
qnx->resize = false;
free(data);
}
static bool gfx_ctx_qnx_init(void *data)
static void *gfx_ctx_qnx_init(void *video_driver)
{
EGLint n;
EGLint major, minor;
@ -65,6 +69,10 @@ static bool gfx_ctx_qnx_init(void *data)
};
int angle, size[2];
int usage, format = SCREEN_FORMAT_RGBX8888;
qnx_ctx_data_t *qnx = (qnx_ctx_data_t*)calloc(1, sizeof(*qnx));
if (!qnx)
goto screen_error;
/* Create a screen context that will be used to
* create an EGL surface to receive libscreen events */
@ -101,41 +109,41 @@ static bool gfx_ctx_qnx_init(void *data)
goto error;
}
if (!egl_init_context(EGL_DEFAULT_DISPLAY, &major, &minor,
if (!egl_init_context(qnx, EGL_DEFAULT_DISPLAY, &major, &minor,
&n, attribs))
{
egl_report_error();
goto error;
}
if (!egl_create_context(context_attributes))
if (!egl_create_context(qnx, context_attributes))
{
egl_report_error();
goto error;
}
if(!screen_win)
if(!qnx->screen_win)
{
if (screen_create_window(&screen_win, screen_ctx))
if (screen_create_window(&qnx->screen_win, screen_ctx))
{
RARCH_ERR("screen_create_window failed:.\n");
RARCH_ERR("screen_create_window failed:.\n");
goto error;
}
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_FORMAT, &format))
if (screen_set_window_property_iv(qnx->screen_win, SCREEN_PROPERTY_FORMAT, &format))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_FORMAT] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_USAGE, &usage))
if (screen_set_window_property_iv(qnx->screen_win, SCREEN_PROPERTY_USAGE, &usage))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_USAGE] failed.\n");
goto error;
}
if (screen_get_window_property_pv(screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&screen_disp))
if (screen_get_window_property_pv(qnx->screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&qnx->screen_disp))
{
RARCH_ERR("screen_get_window_property_pv [SCREEN_PROPERTY_DISPLAY] failed.\n");
goto error;
@ -143,7 +151,7 @@ static bool gfx_ctx_qnx_init(void *data)
int screen_resolution[2];
if (screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution))
if (screen_get_display_property_iv(qnx->screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_SIZE] failed.\n");
goto error;
@ -153,13 +161,13 @@ static bool gfx_ctx_qnx_init(void *data)
angle = atoi(getenv("ORIENTATION"));
screen_display_mode_t screen_mode;
if (screen_get_display_property_pv(screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode))
if (screen_get_display_property_pv(qnx->screen_disp, SCREEN_PROPERTY_MODE, (void**)&screen_mode))
{
RARCH_ERR("screen_get_display_property_pv [SCREEN_PROPERTY_MODE] failed.\n");
goto error;
}
if (screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size))
if (screen_get_window_property_iv(qnx->screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size))
{
RARCH_ERR("screen_get_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
@ -192,36 +200,36 @@ static bool gfx_ctx_qnx_init(void *data)
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
if (screen_set_window_property_iv(qnx->screen_win, SCREEN_PROPERTY_BUFFER_SIZE, buffer_size))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_BUFFER_SIZE] failed.\n");
goto error;
}
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ROTATION, &angle))
if (screen_set_window_property_iv(qnx->screen_win, SCREEN_PROPERTY_ROTATION, &angle))
{
RARCH_ERR("screen_set_window_property_iv [SCREEN_PROPERTY_ROTATION] failed.\n");
goto error;
}
#endif
if (screen_create_window_buffers(screen_win, WINDOW_BUFFERS))
if (screen_create_window_buffers(qnx->screen_win, WINDOW_BUFFERS))
{
RARCH_ERR("screen_create_window_buffers failed.\n");
goto error;
}
if (!egl_create_surface(screen_win))
if (!egl_create_surface(qnx->screen_win))
goto error;
return true;
return "egl";
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_qnx_destroy(data);
gfx_ctx_qnx_destroy(video_driver);
screen_error:
screen_stop_events(screen_ctx);
return false;
return NULL;
}
static void gfx_ctx_qnx_check_window(void *data, bool *quit,

6
gfx/drivers_context/cgl_ctx.c
View File

@ -304,7 +304,7 @@ static CGSSurfaceID attach_gl_context_to_window(CGLContextObj glCtx,
return sid;
}
static bool gfx_ctx_cgl_init(void *data)
static void *gfx_ctx_cgl_init(void *video_driver)
{
CGError err;
gfx_ctx_cgl_data_t *cgl = (gfx_ctx_cgl_data_t*)calloc(1, sizeof(gfx_ctx_cgl_data_t));
@ -333,12 +333,12 @@ static bool gfx_ctx_cgl_init(void *data)
gfx_ctx_data_set(cgl);
return true;
return cgl;
error:
gfx_ctx_cgl_destroy(cgl);
return false;
return NULL;
}
const gfx_ctx_driver_t gfx_ctx_cgl = {

6
gfx/drivers_context/cocoa_gl_ctx.m
View File

@ -148,9 +148,9 @@ void cocoagl_gfx_ctx_update(void)
#endif
}
static bool cocoagl_gfx_ctx_init(void *data)
static void *cocoagl_gfx_ctx_init(void *video_driver)
{
(void)data;
(void)video_driver;
#if defined(HAVE_COCOA)
CocoaView *g_view = (CocoaView*)nsview_get_ptr();
@ -196,7 +196,7 @@ static bool cocoagl_gfx_ctx_init(void *data)
[g_context makeCurrentContext];
// Make sure the view was created
[CocoaView get];
return true;
return "cocoa";
}
static void cocoagl_gfx_ctx_destroy(void *data)

6
gfx/drivers_context/d3d_ctx.cpp
View File

@ -159,13 +159,13 @@ static bool gfx_ctx_d3d_bind_api(void *data,
#endif
}
static bool gfx_ctx_d3d_init(void *data)
static void *gfx_ctx_d3d_init(void *video_driver)
{
(void)data;
(void)video_driver;
win32_monitor_init();
return true;
return "d3d";
}
static void gfx_ctx_d3d_destroy(void *data)

72
gfx/drivers_context/drm_egl_ctx.c
View File

@ -59,15 +59,12 @@ static bool waiting_for_flip;
typedef struct gfx_ctx_drm_egl_data
{
egl_ctx_data_t egl;
RFILE *g_drm;
unsigned g_fb_width;
unsigned g_fb_height;
} gfx_ctx_drm_egl_data_t;
static unsigned g_major;
static unsigned g_minor;
struct drm_fb
{
struct gbm_bo *bo;
@ -117,7 +114,8 @@ error:
static void gfx_ctx_drm_egl_swap_interval(void *data, unsigned interval)
{
g_interval = interval;
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)data;
drm->egl.interval = interval;
if (interval > 1)
RARCH_WARN("[KMS/EGL]: Swap intervals > 1 currently not supported. Will use swap interval of 1.\n");
}
@ -206,6 +204,7 @@ static bool queue_flip(void)
static void gfx_ctx_drm_egl_swap_buffers(void *data)
{
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)data;
egl_swap_buffers(data);
/* I guess we have to wait for flip to have taken
@ -213,7 +212,7 @@ static void gfx_ctx_drm_egl_swap_buffers(void *data)
*
* If true, we are still waiting for a flip
* (nonblocking mode, so just drop the frame). */
if (wait_flip(g_interval))
if (wait_flip(drm->egl.interval))
return;
waiting_for_flip = queue_flip();
@ -250,8 +249,7 @@ static void gfx_ctx_drm_egl_update_window_title(void *data)
static void gfx_ctx_drm_egl_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)data;
if (!drm)
return;
@ -290,7 +288,7 @@ static void gfx_ctx_drm_egl_destroy_resources(gfx_ctx_drm_egl_data_t *drm)
/* Make sure we acknowledge all page-flips. */
wait_flip(true);
egl_destroy(NULL);
egl_destroy(drm);
/* Restore original CRTC. */
drm_restore_crtc();
@ -307,7 +305,7 @@ static void gfx_ctx_drm_egl_destroy_resources(gfx_ctx_drm_egl_data_t *drm)
g_next_bo = NULL;
}
static bool gfx_ctx_drm_egl_init(void *data)
static void *gfx_ctx_drm_egl_init(void *video_driver)
{
int fd, i;
unsigned monitor_index;
@ -317,7 +315,7 @@ static bool gfx_ctx_drm_egl_init(void *data)
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)calloc(1, sizeof(gfx_ctx_drm_egl_data_t));
if (!drm)
return false;
return NULL;
fd = -1;
gpu_descriptors = dir_list_new("/dev/dri", NULL, false, false);
@ -368,8 +366,6 @@ nextgpu:
dir_list_free(gpu_descriptors);
gfx_ctx_data_set(drm);
/* Setup the flip handler. */
g_drm_fds.fd = fd;
g_drm_fds.events = POLLIN;
@ -378,7 +374,7 @@ nextgpu:
g_drm_fd = fd;
return true;
return drm;
error:
dir_list_free(gpu_descriptors);
@ -388,17 +384,17 @@ error:
if (drm)
free(drm);
return false;
return NULL;
}
static EGLint *egl_fill_attribs(EGLint *attr)
static EGLint *egl_fill_attribs(gfx_ctx_drm_egl_data_t *drm, EGLint *attr)
{
switch (g_egl_api)
switch (drm->egl.api)
{
#ifdef EGL_KHR_create_context
case GFX_CTX_OPENGL_API:
{
unsigned version = g_major * 1000 + g_minor;
unsigned version = drm->egl.major * 1000 + drm->egl.minor;
bool core = version >= 3001;
#ifdef GL_DEBUG
bool debug = true;
@ -411,9 +407,9 @@ static EGLint *egl_fill_attribs(EGLint *attr)
if (core)
{
*attr++ = EGL_CONTEXT_MAJOR_VERSION_KHR;
*attr++ = g_major;
*attr++ = drm->egl.major;
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = drm->egl.minor;
/* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending
@ -437,12 +433,12 @@ static EGLint *egl_fill_attribs(EGLint *attr)
case GFX_CTX_OPENGL_ES_API:
*attr++ = EGL_CONTEXT_CLIENT_VERSION;
*attr++ = g_major ? (EGLint)g_major : 2;
*attr++ = drm->egl.major ? (EGLint)drm->egl.major : 2;
#ifdef EGL_KHR_create_context
if (g_minor > 0)
if (drm->egl.minor > 0)
{
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = drm->egl.minor;
}
#endif
break;
@ -499,8 +495,7 @@ static bool gfx_ctx_drm_egl_set_video_mode(void *data,
int i, ret = 0;
struct drm_fb *fb = NULL;
settings_t *settings = config_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)data;
if (!drm)
return false;
@ -514,7 +509,7 @@ static bool gfx_ctx_drm_egl_set_video_mode(void *data,
break;
case GFX_CTX_OPENGL_ES_API:
#ifdef EGL_KHR_create_context
if (g_major >= 3)
if (drm->egl.major >= 3)
attrib_ptr = egl_attribs_gles3;
else
#endif
@ -587,27 +582,27 @@ static bool gfx_ctx_drm_egl_set_video_mode(void *data,
}
if (!egl_init_context((EGLNativeDisplayType)g_gbm_dev, &major,
if (!egl_init_context(drm, (EGLNativeDisplayType)g_gbm_dev, &major,
&minor, &n, attrib_ptr))
{
egl_report_error();
goto error;
}
attr = egl_fill_attribs(egl_attribs);
attr = egl_fill_attribs(drm, egl_attribs);
egl_attribs_ptr = &egl_attribs[0];
if (!egl_create_context((attr != egl_attribs_ptr) ? egl_attribs_ptr : NULL))
if (!egl_create_context(drm, (attr != egl_attribs_ptr) ? egl_attribs_ptr : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface((EGLNativeWindowType)g_gbm_surface))
if (!egl_create_surface(drm, (EGLNativeWindowType)g_gbm_surface))
goto error;
glClear(GL_COLOR_BUFFER_BIT);
egl_swap_buffers(NULL);
egl_swap_buffers(drm);
g_bo = gbm_surface_lock_front_buffer(g_gbm_surface);
fb = drm_fb_get_from_bo(g_bo);
@ -631,14 +626,13 @@ error:
static void gfx_ctx_drm_egl_destroy(void *data)
{
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)data;
if (!drm)
return;
gfx_ctx_drm_egl_destroy_resources(drm);
gfx_ctx_free_data();
free(drm);
}
static void gfx_ctx_drm_egl_input_driver(void *data,
@ -667,14 +661,14 @@ static bool gfx_ctx_drm_egl_has_windowed(void *data)
return false;
}
static bool gfx_ctx_drm_egl_bind_api(void *data,
static bool gfx_ctx_drm_egl_bind_api(void *video_driver,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
(void)video_driver;
g_major = major;
g_minor = minor;
g_egl_api = api;
g_egl_major = major;
g_egl_minor = minor;
g_egl_api = api;
switch (api)
{

12
gfx/drivers_context/emscriptenegl_ctx.c
View File

@ -101,7 +101,7 @@ static void gfx_ctx_emscripten_get_video_size(void *data,
static void gfx_ctx_emscripten_destroy(void *data);
static bool gfx_ctx_emscripten_init(void *data)
static void *gfx_ctx_emscripten_init(void *video_driver)
{
EGLint width, height, n, major, minor;
static const EGLint attribute_list[] =
@ -119,12 +119,12 @@ static bool gfx_ctx_emscripten_init(void *data)
EGL_NONE
};
(void)data;
(void)video_driver;
if (g_egl_inited)
{
RARCH_LOG("[EMSCRIPTEN/EGL]: Attempted to re-initialize driver.\n");
return true;
return (void*)"emscripten";
}
if (!egl_init_context(EGL_DEFAULT_DISPLAY, &major, &minor,
@ -149,11 +149,11 @@ static bool gfx_ctx_emscripten_init(void *data)
g_fb_height = height;
RARCH_LOG("[EMSCRIPTEN/EGL]: Dimensions: %ux%u\n", width, height);
return true;
return (void*)"emscripten";
error:
gfx_ctx_emscripten_destroy(data);
return false;
gfx_ctx_emscripten_destroy(video_driver);
return NULL;
}
static bool gfx_ctx_emscripten_set_video_mode(void *data,

6
gfx/drivers_context/gfx_null_ctx.c
View File

@ -125,11 +125,11 @@ static void gfx_ctx_null_bind_hw_render(void *data, bool enable)
(void)enable;
}
static bool gfx_ctx_null_init(void *data)
static void *gfx_ctx_null_init(void *video_driver)
{
(void)data;
(void)video_driver;
return true;
return (void*)"null";
}
const gfx_ctx_driver_t gfx_ctx_null = {

25
gfx/drivers_context/glx_ctx.c
View File

@ -116,8 +116,7 @@ static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx)
static void gfx_ctx_glx_destroy(void *data)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)data;
if (!glx)
return;
@ -125,13 +124,12 @@ static void gfx_ctx_glx_destroy(void *data)
(void)data;
ctx_glx_destroy_resources(glx);
gfx_ctx_free_data();
free(data);
}
static void gfx_ctx_glx_swap_interval(void *data, unsigned interval)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)data;
glx->g_interval = interval;
@ -156,8 +154,7 @@ static void gfx_ctx_glx_swap_interval(void *data, unsigned interval)
static void gfx_ctx_glx_swap_buffers(void *data)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)data;
if (glx->g_is_double)
glXSwapBuffers(g_x11_dpy, glx->g_glx_win);
@ -171,7 +168,7 @@ static void gfx_ctx_glx_set_resize(void *data,
(void)height;
}
static bool gfx_ctx_glx_init(void *data)
static void *gfx_ctx_glx_init(void *data)
{
static const int visual_attribs[] = {
GLX_X_RENDERABLE , True,
@ -241,9 +238,7 @@ static bool gfx_ctx_glx_init(void *data)
glx->g_fbc = fbcs[0];
XFree(fbcs);
gfx_ctx_data_set(glx);
return true;
return glx;
error:
ctx_glx_destroy_resources(glx);
@ -252,7 +247,7 @@ error:
free(glx);
g_x11_screen = 0;
return false;
return NULL;
}
static bool gfx_ctx_glx_set_video_mode(void *data,
@ -266,8 +261,7 @@ static bool gfx_ctx_glx_set_video_mode(void *data,
XSetWindowAttributes swa = {0};
int (*old_handler)(Display*, XErrorEvent*) = NULL;
settings_t *settings = config_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)data;
x11_install_sighandlers();
@ -555,8 +549,7 @@ static void gfx_ctx_glx_show_mouse(void *data, bool state)
static void gfx_ctx_glx_bind_hw_render(void *data, bool enable)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)data;
if (!glx)
return;

8
gfx/drivers_context/mali_fbdev_ctx.c
View File

@ -61,7 +61,7 @@ static void gfx_ctx_mali_fbdev_get_video_size(void *data,
*height = g_height;
}
static bool gfx_ctx_mali_fbdev_init(void *data)
static void *gfx_ctx_mali_fbdev_init(void *video_driver)
{
EGLint n;
EGLint major, minor;
@ -88,12 +88,12 @@ static bool gfx_ctx_mali_fbdev_init(void *data)
goto error;
}
return true;
return (void*)"mali";
error:
RARCH_ERR("[Mali fbdev]: EGL error: %d.\n", eglGetError());
gfx_ctx_mali_fbdev_destroy(data);
return false;
gfx_ctx_mali_fbdev_destroy(video_driver);
return NULL;
}
static void gfx_ctx_mali_fbdev_check_window(void *data, bool *quit,

20
gfx/drivers_context/ps3_ctx.c
View File

@ -207,10 +207,7 @@ static void gfx_ctx_ps3_update_window_title(void *data)
static void gfx_ctx_ps3_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)
gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)data;
#if defined(HAVE_PSGL)
if (ps3)
@ -218,7 +215,7 @@ static void gfx_ctx_ps3_get_video_size(void *data,
#endif
}
static bool gfx_ctx_ps3_init(void *data)
static void *gfx_ctx_ps3_init(void *video_driver)
{
#ifdef HAVE_PSGL
PSGLdeviceParameters params;
@ -228,11 +225,11 @@ static bool gfx_ctx_ps3_init(void *data)
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)
calloc(1, sizeof(gfx_ctx_ps3_data_t));
(void)data;
(void)video_driver;
(void)global;
if (!ps3)
return false;
return NULL;
#if defined(HAVE_PSGL)
options.enable = PSGL_INIT_MAX_SPUS | PSGL_INIT_INITIALIZE_SPUS;
@ -291,9 +288,7 @@ static bool gfx_ctx_ps3_init(void *data)
gfx_ctx_ps3_get_available_resolutions();
gfx_ctx_data_set(ps3);
return true;
return ps3;
}
static bool gfx_ctx_ps3_set_video_mode(void *data,
@ -326,10 +321,7 @@ static void gfx_ctx_ps3_destroy_resources(gfx_ctx_ps3_data_t *ps3)
static void gfx_ctx_ps3_destroy(void *data)
{
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)
gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)data;
if (!ps3)
return;

32
gfx/drivers_context/sdl_gl_ctx.c
View File

@ -65,13 +65,13 @@ static void sdl_ctx_destroy_resources(gfx_ctx_sdl_data_t *sdl)
SDL_QuitSubSystem(SDL_INIT_VIDEO);
}
static bool sdl_ctx_init(void *data)
static void *sdl_ctx_init(void *video_driver)
{
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)
calloc(1, sizeof(gfx_ctx_sdl_data_t));
if (!sdl)
return false;
return NULL;
#ifdef HAVE_X11
XInitThreads();
@ -88,9 +88,7 @@ static bool sdl_ctx_init(void *data)
RARCH_LOG("[SDL_GL] SDL %i.%i.%i gfx context driver initialized.\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
gfx_ctx_data_set(sdl);
return true;
return sdl;
error:
RARCH_WARN("[SDL_GL]: Failed to initialize SDL gfx context driver: %s\n",
@ -101,20 +99,18 @@ error:
if (sdl)
free(sdl);
return false;
return NULL;
}
static void sdl_ctx_destroy(void *data)
{
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
if (!sdl)
return;
(void)data;
sdl_ctx_destroy_resources(sdl);
gfx_ctx_free_data();
free(sdl);
}
static bool sdl_ctx_bind_api(void *data, enum gfx_ctx_api api, unsigned major,
@ -162,9 +158,7 @@ static bool sdl_ctx_set_video_mode(void *data, unsigned width, unsigned height,
{
unsigned fsflag = 0;
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
sdl->g_new_width = width;
sdl->g_new_height = height;
@ -231,7 +225,7 @@ static void sdl_ctx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
if (!sdl)
return;
@ -269,7 +263,7 @@ static void sdl_ctx_update_window_title(void *data)
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
if (!sdl)
return;
@ -291,9 +285,7 @@ static void sdl_ctx_check_window(void *data, bool *quit, bool *resize,unsigned *
unsigned *height, unsigned frame_count)
{
SDL_Event event;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
SDL_PumpEvents();
@ -354,7 +346,7 @@ static bool sdl_ctx_has_focus(void *data)
unsigned flags;
#ifdef HAVE_SDL2
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
flags = (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
return (SDL_GetWindowFlags(sdl->g_win) & flags) == flags;
#else
@ -381,7 +373,7 @@ static bool sdl_ctx_has_windowed(void *data)
static void sdl_ctx_swap_buffers(void *data)
{
#ifdef HAVE_SDL2
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)gfx_ctx_data_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)data;
SDL_GL_SwapWindow(sdl->g_win);
#else
SDL_GL_SwapBuffers();

10
gfx/drivers_context/vc_egl_ctx.c
View File

@ -131,7 +131,7 @@ static void gfx_ctx_vc_get_video_size(void *data,
static void gfx_ctx_vc_destroy(void *data);
static bool gfx_ctx_vc_init(void *data)
static void *gfx_ctx_vc_init(void *video_driver)
{
VC_DISPMANX_ALPHA_T alpha;
EGLint n, major, minor;
@ -164,7 +164,7 @@ static bool gfx_ctx_vc_init(void *data)
if (g_egl_inited)
{
RARCH_ERR("[VC/EGL]: Attempted to re-initialize driver.\n");
return false;
return (void*)"vc";
}
bcm_host_init();
@ -262,11 +262,11 @@ static bool gfx_ctx_vc_init(void *data)
if (!egl_create_surface(&nativewindow))
goto error;
return true;
return (void*)"vc";
error:
gfx_ctx_vc_destroy(data);
return false;
gfx_ctx_vc_destroy(video_driver);
return NULL;
}
static bool gfx_ctx_vc_set_video_mode(void *data,

10
gfx/drivers_context/vivante_fbdev_ctx.c
View File

@ -32,7 +32,7 @@ static void gfx_ctx_vivante_destroy(void *data)
g_resize = false;
}
static bool gfx_ctx_vivante_init(void *data)
static void *gfx_ctx_vivante_init(void *video_driver)
{
EGLint n;
EGLint major, minor;
@ -50,7 +50,7 @@ static bool gfx_ctx_vivante_init(void *data)
EGL_NONE
};
(void)data;
(void)video_driver;
egl_install_sighandlers();
@ -61,12 +61,12 @@ static bool gfx_ctx_vivante_init(void *data)
goto error;
}
return true;
return (void*)"vivante";
error:
RARCH_ERR("[Vivante fbdev]: EGL error: %d.\n", eglGetError());
gfx_ctx_vivante_destroy(data);
return false;
gfx_ctx_vivante_destroy(video_driver);
return NULL;
}
static void gfx_ctx_vivante_check_window(void *data, bool *quit,

265
gfx/drivers_context/wayland_ctx.c
View File

@ -28,26 +28,22 @@
typedef struct gfx_ctx_wayland_data
{
bool g_resize;
int g_fd;
unsigned g_width;
unsigned g_height;
struct wl_display *g_dpy;
struct wl_registry *g_registry;
struct wl_compositor *g_compositor;
struct wl_surface *g_surface;
struct wl_shell_surface *g_shell_surf;
struct wl_shell *g_shell;
struct wl_egl_window *g_win;
struct wl_keyboard *g_wl_keyboard;
struct wl_pointer *g_wl_pointer;
egl_ctx_data_t egl;
bool resize;
int fd;
unsigned width;
unsigned height;
struct wl_display *dpy;
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_surface *surface;
struct wl_shell_surface *shell_surf;
struct wl_shell *shell;
struct wl_egl_window *win;
struct wl_keyboard *wl_keyboard;
struct wl_pointer *wl_pointer;
} gfx_ctx_wayland_data_t;
static unsigned g_major;
static unsigned g_minor;
#ifndef EGL_OPENGL_ES3_BIT_KHR
#define EGL_OPENGL_ES3_BIT_KHR 0x0040
#endif
@ -65,18 +61,16 @@ static void shell_surface_handle_configure(void *data,
struct wl_shell_surface *shell_surface,
uint32_t edges, int32_t width, int32_t height)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)data;
(void)shell_surface;
(void)edges;
wl->g_width = width;
wl->g_height = height;
wl->width = width;
wl->height = height;
RARCH_LOG("[Wayland/EGL]: Surface configure: %u x %u.\n",
wl->g_width, wl->g_height);
wl->width, wl->height);
}
static void shell_surface_handle_popup_done(void *data,
@ -96,16 +90,14 @@ static const struct wl_shell_surface_listener shell_surface_listener = {
static void registry_handle_global(void *data, struct wl_registry *reg,
uint32_t id, const char *interface, uint32_t version)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)data;
(void)version;
if (!strcmp(interface, "wl_compositor"))
wl->g_compositor = (struct wl_compositor*)wl_registry_bind(reg, id, &wl_compositor_interface, 1);
wl->compositor = (struct wl_compositor*)wl_registry_bind(reg, id, &wl_compositor_interface, 1);
else if (!strcmp(interface, "wl_shell"))
wl->g_shell = (struct wl_shell*)wl_registry_bind(reg, id, &wl_shell_interface, 1);
wl->shell = (struct wl_shell*)wl_registry_bind(reg, id, &wl_shell_interface, 1);
}
static void registry_handle_global_remove(void *data,
@ -131,37 +123,37 @@ static void gfx_ctx_wl_destroy_resources(gfx_ctx_wayland_data_t *wl)
if (!wl)
return;
egl_destroy(NULL);
egl_destroy(wl);
if (wl->g_win)
wl_egl_window_destroy(wl->g_win);
if (wl->g_shell)
wl_shell_destroy(wl->g_shell);
if (wl->g_compositor)
wl_compositor_destroy(wl->g_compositor);
if (wl->g_registry)
wl_registry_destroy(wl->g_registry);
if (wl->g_shell_surf)
wl_shell_surface_destroy(wl->g_shell_surf);
if (wl->g_surface)
wl_surface_destroy(wl->g_surface);
if (wl->win)
wl_egl_window_destroy(wl->win);
if (wl->shell)
wl_shell_destroy(wl->shell);
if (wl->compositor)
wl_compositor_destroy(wl->compositor);
if (wl->registry)
wl_registry_destroy(wl->registry);
if (wl->shell_surf)
wl_shell_surface_destroy(wl->shell_surf);
if (wl->surface)
wl_surface_destroy(wl->surface);
if (wl->g_dpy)
if (wl->dpy)
{
wl_display_flush(wl->g_dpy);
wl_display_disconnect(wl->g_dpy);
wl_display_flush(wl->dpy);
wl_display_disconnect(wl->dpy);
}
wl->g_win = NULL;
wl->g_shell = NULL;
wl->g_compositor = NULL;
wl->g_registry = NULL;
wl->g_dpy = NULL;
wl->g_shell_surf = NULL;
wl->g_surface = NULL;
wl->win = NULL;
wl->shell = NULL;
wl->compositor = NULL;
wl->registry = NULL;
wl->dpy = NULL;
wl->shell_surf = NULL;
wl->surface = NULL;
wl->g_width = 0;
wl->g_height = 0;
wl->width = 0;
wl->height = 0;
}
static void flush_wayland_fd(void)
@ -170,24 +162,24 @@ static void flush_wayland_fd(void)
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
wl_display_dispatch_pending(wl->g_dpy);
wl_display_flush(wl->g_dpy);
wl_display_dispatch_pending(wl->dpy);
wl_display_flush(wl->dpy);
fd.fd = wl->g_fd;
fd.fd = wl->fd;
fd.events = POLLIN | POLLOUT | POLLERR | POLLHUP;
if (poll(&fd, 1, 0) > 0)
{
if (fd.revents & (POLLERR | POLLHUP))
{
close(wl->g_fd);
close(wl->fd);
g_egl_quit = true;
}
if (fd.revents & POLLIN)
wl_display_dispatch(wl->g_dpy);
wl_display_dispatch(wl->dpy);
if (fd.revents & POLLOUT)
wl_display_flush(wl->g_dpy);
wl_display_flush(wl->dpy);
}
}
@ -218,12 +210,9 @@ static void gfx_ctx_wl_check_window(void *data, bool *quit,
static void gfx_ctx_wl_set_resize(void *data, unsigned width, unsigned height)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)data;
wl_egl_window_resize(wl->g_win, width, height, 0, 0);
wl_egl_window_resize(wl->win, width, height, 0, 0);
}
static void gfx_ctx_wl_update_window_title(void *data)
@ -231,14 +220,11 @@ static void gfx_ctx_wl_update_window_title(void *data)
char buf[128] = {0};
char buf_fps[128] = {0};
settings_t *settings = config_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
wl_shell_surface_set_title(wl->g_shell_surf, buf);
wl_shell_surface_set_title(wl->shell_surf, buf);
if (settings->fps_show)
runloop_msg_queue_push(buf_fps, 1, 1, false);
@ -247,13 +233,10 @@ static void gfx_ctx_wl_update_window_title(void *data)
static void gfx_ctx_wl_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)data;
*width = wl->g_width;
*height = wl->g_height;
*width = wl->width;
*height = wl->height;
}
#define DEFAULT_WINDOWED_WIDTH 640
@ -267,7 +250,7 @@ static void gfx_ctx_wl_get_video_size(void *data,
EGL_ALPHA_SIZE, 0, \
EGL_DEPTH_SIZE, 0
static bool gfx_ctx_wl_init(void *data)
static void *gfx_ctx_wl_init(void *video_driver)
{
static const EGLint egl_attribs_gl[] = {
WL_EGL_ATTRIBS_BASE,
@ -301,19 +284,19 @@ static bool gfx_ctx_wl_init(void *data)
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
calloc(1, sizeof(gfx_ctx_wayland_data_t));
(void)data;
(void)video_driver;
if (!wl)
return false;
return NULL;
switch (g_egl_api)
switch (wl->egl.api)
{
case GFX_CTX_OPENGL_API:
attrib_ptr = egl_attribs_gl;
break;
case GFX_CTX_OPENGL_ES_API:
#ifdef EGL_KHR_create_context
if (g_major >= 3)
if (g_egl_major >= 3)
attrib_ptr = egl_attribs_gles3;
else
#endif
@ -328,44 +311,43 @@ static bool gfx_ctx_wl_init(void *data)
g_egl_quit = 0;
wl->g_dpy = wl_display_connect(NULL);
if (!wl->g_dpy)
wl->dpy = wl_display_connect(NULL);
if (!wl->dpy)
{
RARCH_ERR("Failed to connect to Wayland server.\n");
goto error;
}
gfx_ctx_data_set(wl);
wl->registry = wl_display_get_registry(wl->dpy);
wl_registry_add_listener(wl->registry, &registry_listener, wl);
wl_display_dispatch(wl->dpy);
wl_display_roundtrip(wl->dpy);
wl->g_registry = wl_display_get_registry(wl->g_dpy);
wl_registry_add_listener(wl->g_registry, &registry_listener, NULL);
wl_display_dispatch(wl->g_dpy);
if (!wl->g_compositor)
if (!wl->compositor)
{
RARCH_ERR("Failed to create compositor.\n");
goto error;
}
if (!wl->g_shell)
if (!wl->shell)
{
RARCH_ERR("Failed to create shell.\n");
goto error;
}
wl->g_fd = wl_display_get_fd(wl->g_dpy);
wl->fd = wl_display_get_fd(wl->dpy);
if (!egl_init_context((EGLNativeDisplayType)wl->g_dpy,
if (!egl_init_context(wl, (EGLNativeDisplayType)wl->dpy,
&major, &minor, &n, attrib_ptr))
{
egl_report_error();
goto error;
}
if (n == 0 || !egl_has_config())
if (n == 0 || !egl_has_config(wl))
goto error;
return true;
return wl;
error:
gfx_ctx_wl_destroy_resources(wl);
@ -373,19 +355,17 @@ error:
if (wl)
free(wl);
gfx_ctx_free_data();
return false;
return NULL;
}
static EGLint *egl_fill_attribs(EGLint *attr)
static EGLint *egl_fill_attribs(gfx_ctx_wayland_data_t *wl, EGLint *attr)
{
switch (g_egl_api)
switch (wl->egl.api)
{
#ifdef EGL_KHR_create_context
case GFX_CTX_OPENGL_API:
{
unsigned version = g_major * 1000 + g_minor;
unsigned version = wl->egl.major * 1000 + wl->egl.minor;
bool core = version >= 3001;
#ifdef GL_DEBUG
bool debug = true;
@ -398,9 +378,9 @@ static EGLint *egl_fill_attribs(EGLint *attr)
if (core)
{
*attr++ = EGL_CONTEXT_MAJOR_VERSION_KHR;
*attr++ = g_major;
*attr++ = wl->egl.major;
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = wl->egl.minor;
/* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending on GL_ARB_compatibility. */
if (version >= 3002)
@ -422,12 +402,12 @@ static EGLint *egl_fill_attribs(EGLint *attr)
case GFX_CTX_OPENGL_ES_API:
*attr++ = EGL_CONTEXT_CLIENT_VERSION; /* Same as EGL_CONTEXT_MAJOR_VERSION */
*attr++ = g_major ? (EGLint)g_major : 2;
*attr++ = wl->egl.major ? (EGLint)wl->egl.major : 2;
#ifdef EGL_KHR_create_context
if (g_minor > 0)
if (wl->egl.minor > 0)
{
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = wl->egl.minor;
}
#endif
break;
@ -442,17 +422,14 @@ static EGLint *egl_fill_attribs(EGLint *attr)
static void gfx_ctx_wl_destroy(void *data)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
(void)data;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (!wl)
return;
gfx_ctx_wl_destroy_resources(wl);
gfx_ctx_free_data();
free(wl);
}
static bool gfx_ctx_wl_set_video_mode(void *data,
@ -461,38 +438,37 @@ static bool gfx_ctx_wl_set_video_mode(void *data,
{
EGLint egl_attribs[16];
EGLint *attr = NULL;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
egl_install_sighandlers();
attr = egl_fill_attribs(egl_attribs);
attr = egl_fill_attribs(wl, egl_attribs);
wl->g_width = width ? width : DEFAULT_WINDOWED_WIDTH;
wl->g_height = height ? height : DEFAULT_WINDOWED_HEIGHT;
wl->width = width ? width : DEFAULT_WINDOWED_WIDTH;
wl->height = height ? height : DEFAULT_WINDOWED_HEIGHT;
wl->g_surface = wl_compositor_create_surface(wl->g_compositor);
wl->g_win = wl_egl_window_create(wl->g_surface, wl->g_width, wl->g_height);
wl->g_shell_surf = wl_shell_get_shell_surface(wl->g_shell, wl->g_surface);
wl->surface = wl_compositor_create_surface(wl->compositor);
wl->win = wl_egl_window_create(wl->surface, wl->width, wl->height);
wl->shell_surf = wl_shell_get_shell_surface(wl->shell, wl->surface);
wl_shell_surface_add_listener(wl->g_shell_surf, &shell_surface_listener, NULL);
wl_shell_surface_set_toplevel(wl->g_shell_surf);
wl_shell_surface_set_class(wl->g_shell_surf, "RetroArch");
wl_shell_surface_set_title(wl->g_shell_surf, "RetroArch");
wl_shell_surface_add_listener(wl->shell_surf, &shell_surface_listener, NULL);
wl_shell_surface_set_toplevel(wl->shell_surf);
wl_shell_surface_set_class(wl->shell_surf, "RetroArch");
wl_shell_surface_set_title(wl->shell_surf, "RetroArch");
if (!egl_create_context((attr != egl_attribs) ? egl_attribs : NULL))
if (!egl_create_context(wl, (attr != egl_attribs) ? egl_attribs : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface((EGLNativeWindowType)wl->g_win))
if (!egl_create_surface(wl, (EGLNativeWindowType)wl->win))
goto error;
egl_set_swap_interval(data, g_interval);
egl_set_swap_interval(wl, wl->egl.interval);
if (fullscreen)
wl_shell_surface_set_fullscreen(wl->g_shell_surf, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
wl_shell_surface_set_fullscreen(wl->shell_surf, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
flush_wayland_fd();
return true;
@ -534,14 +510,12 @@ static bool gfx_ctx_wl_has_windowed(void *data)
return true;
}
static bool gfx_ctx_wl_bind_api(void *data,
static bool gfx_ctx_wl_bind_api(void *video_driver,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
g_egl_api = api;
g_egl_major = major;
g_egl_minor = minor;
g_egl_api = api;
switch (api)
{
@ -679,28 +653,27 @@ static const struct wl_pointer_listener pointer_listener = {
static void seat_handle_capabilities(void *data,
struct wl_seat *seat, unsigned caps)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
gfx_ctx_data_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !wl->g_wl_keyboard)
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !wl->wl_keyboard)
{
wl->g_wl_keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(wl->g_wl_keyboard, &keyboard_listener, NULL);
wl->wl_keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(wl->wl_keyboard, &keyboard_listener, NULL);
}
else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && wl->g_wl_keyboard)
else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && wl->wl_keyboard)
{
wl_keyboard_destroy(wl->g_wl_keyboard);
wl->g_wl_keyboard = NULL;
wl_keyboard_destroy(wl->wl_keyboard);
wl->wl_keyboard = NULL;
}
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !wl->g_wl_pointer)
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !wl->wl_pointer)
{
wl->g_wl_pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(wl->g_wl_pointer, &pointer_listener, NULL);
wl->wl_pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(wl->wl_pointer, &pointer_listener, NULL);
}
else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && wl->g_wl_pointer)
else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && wl->wl_pointer)
{
wl_pointer_destroy(wl->g_wl_pointer);
wl->g_wl_pointer = NULL;
wl_pointer_destroy(wl->wl_pointer);
wl->wl_pointer = NULL;
}
}

10
gfx/drivers_context/wgl_ctx.cpp
View File

@ -295,23 +295,23 @@ static void gfx_ctx_wgl_get_video_size(void *data, unsigned *width, unsigned *he
}
}
static bool gfx_ctx_wgl_init(void *data)
static void *gfx_ctx_wgl_init(void *video_driver)
{
WNDCLASSEX wndclass = {0};
(void)data;
(void)video_driver;
if (g_inited)
return false;
return NULL;
win32_window_reset();
win32_monitor_init();
wndclass.lpfnWndProc = WndProcGL;
if (!win32_window_init(&wndclass, true, NULL))
return false;
return NULL;
return true;
return (void*)"wgl";
}
static void gfx_ctx_wgl_destroy(void *data)

85
gfx/drivers_context/xegl_ctx.c
View File

@ -27,11 +27,11 @@
#define EGL_OPENGL_ES3_BIT_KHR 0x0040
#endif
static XF86VidModeModeInfo g_desktop_mode;
static bool g_should_reset_mode;
static unsigned g_major;
static unsigned g_minor;
typedef struct {
egl_ctx_data_t egl;
XF86VidModeModeInfo desktop_mode;
bool should_reset_mode;
} xegl_ctx_data_t;
static int egl_nul_handler(Display *dpy, XErrorEvent *event)
{
@ -42,6 +42,8 @@ static int egl_nul_handler(Display *dpy, XErrorEvent *event)
static void gfx_ctx_xegl_destroy(void *data)
{
xegl_ctx_data_t *xegl = (xegl_ctx_data_t*)data;
x11_input_ctx_destroy();
egl_destroy(data);
@ -54,12 +56,14 @@ static void gfx_ctx_xegl_destroy(void *data)
x11_colormap_destroy();
if (g_should_reset_mode)
if (xegl->should_reset_mode)
{
x11_exit_fullscreen(g_x11_dpy, &g_desktop_mode);
g_should_reset_mode = false;
x11_exit_fullscreen(g_x11_dpy, &xegl->desktop_mode);
xegl->should_reset_mode = false;
}
free(data);
/* Do not close g_x11_dpy. We'll keep one for the entire application
* lifecycle to work-around nVidia EGL limitations.
*/
@ -81,7 +85,7 @@ EGL_BLUE_SIZE, 1, \
EGL_ALPHA_SIZE, 0, \
EGL_DEPTH_SIZE, 0
static bool gfx_ctx_xegl_init(void *data)
static void *gfx_ctx_xegl_init(void *video_driver)
{
static const EGLint egl_attribs_gl[] = {
XEGL_ATTRIBS_BASE,
@ -112,20 +116,26 @@ static bool gfx_ctx_xegl_init(void *data)
const EGLint *attrib_ptr;
EGLint major, minor;
EGLint n;
xegl_ctx_data_t *xegl;
if (g_egl_inited)
return false;
return NULL;
XInitThreads();
switch (g_egl_api)
xegl = (xegl_ctx_data_t*)calloc(1, sizeof(xegl_ctx_data_t));
if (!xegl)
return NULL;
switch (xegl->egl.api)
{
case GFX_CTX_OPENGL_API:
attrib_ptr = egl_attribs_gl;
break;
case GFX_CTX_OPENGL_ES_API:
#ifdef EGL_KHR_create_context
if (g_major >= 3)
if (xegl->egl.major >= 3)
attrib_ptr = egl_attribs_gles3;
else
#endif
@ -141,33 +151,33 @@ static bool gfx_ctx_xegl_init(void *data)
if (!x11_connect())
goto error;
if (!egl_init_context((EGLNativeDisplayType)g_x11_dpy,
if (!egl_init_context(xegl, (EGLNativeDisplayType)g_x11_dpy,
&major, &minor, &n, attrib_ptr))
{
egl_report_error();
goto error;
}
if (n == 0 || !egl_has_config())
if (n == 0 || !egl_has_config(xegl))
goto error;
return true;
return xegl;
error:
gfx_ctx_xegl_destroy(data);
return false;
gfx_ctx_xegl_destroy(xegl);
return NULL;
}
static EGLint *xegl_fill_attribs(EGLint *attr)
static EGLint *xegl_fill_attribs(xegl_ctx_data_t *xegl, EGLint *attr)
{
switch (g_egl_api)
switch (xegl->egl.api)
{
#ifdef EGL_KHR_create_context
case GFX_CTX_OPENGL_API:
{
const struct retro_hw_render_callback *hw_render =
(const struct retro_hw_render_callback*)video_driver_callback();
unsigned version = g_major * 1000 + g_minor;
unsigned version = xegl->egl.major * 1000 + xegl->egl.minor;
bool core = version >= 3001;
#ifdef GL_DEBUG
bool debug = true;
@ -178,9 +188,9 @@ static EGLint *xegl_fill_attribs(EGLint *attr)
if (core)
{
*attr++ = EGL_CONTEXT_MAJOR_VERSION_KHR;
*attr++ = g_major;
*attr++ = xegl->egl.major;
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = xegl->egl.minor;
/* Technically, we don't have core/compat until 3.2.
* Version 3.1 is either compat or not depending
@ -206,12 +216,12 @@ static EGLint *xegl_fill_attribs(EGLint *attr)
case GFX_CTX_OPENGL_ES_API:
/* Same as EGL_CONTEXT_MAJOR_VERSION. */
*attr++ = EGL_CONTEXT_CLIENT_VERSION;
*attr++ = g_major ? (EGLint)g_major : 2;
*attr++ = xegl->egl.major ? (EGLint)xegl->egl.major : 2;
#ifdef EGL_KHR_create_context
if (g_minor > 0)
if (xegl->egl.minor > 0)
{
*attr++ = EGL_CONTEXT_MINOR_VERSION_KHR;
*attr++ = g_minor;
*attr++ = xegl->egl.minor;
}
#endif
break;
@ -240,6 +250,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
settings_t *settings = config_get_ptr();
xegl_ctx_data_t *xegl = (xegl_ctx_data_t*)data;
int (*old_handler)(Display*, XErrorEvent*) = NULL;
@ -248,9 +259,9 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
windowed_full = settings->video.windowed_fullscreen;
attr = egl_attribs;
attr = xegl_fill_attribs(attr);
attr = xegl_fill_attribs(xegl, attr);
if (!egl_get_native_visual_id(&vid))
if (!egl_get_native_visual_id(xegl, &vid))
goto error;
temp.visualid = vid;
@ -266,9 +277,9 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
if (fullscreen && !windowed_full)
{
if (x11_enter_fullscreen(g_x11_dpy, width, height, &g_desktop_mode))
if (x11_enter_fullscreen(g_x11_dpy, width, height, &xegl->desktop_mode))
{
g_should_reset_mode = true;
xegl->should_reset_mode = true;
true_full = true;
}
else
@ -306,13 +317,13 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
CWBorderPixel | CWColormap | CWEventMask | (true_full ? CWOverrideRedirect : 0), &swa);
XSetWindowBackground(g_x11_dpy, g_x11_win, 0);
if (!egl_create_context((attr != egl_attribs) ? egl_attribs : NULL))
if (!egl_create_context(xegl, (attr != egl_attribs) ? egl_attribs : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface((EGLNativeWindowType)g_x11_win))
if (!egl_create_surface(xegl, (EGLNativeWindowType)g_x11_win))
goto error;
x11_set_window_attr(g_x11_dpy, g_x11_win);
@ -356,7 +367,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
x11_event_queue_check(&event);
x11_install_quit_atom();
egl_set_swap_interval(data, g_interval);
egl_set_swap_interval(xegl, xegl->egl.interval);
/* This can blow up on some drivers. It's not fatal,
* so override errors for this call.
@ -367,7 +378,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
XSetErrorHandler(old_handler);
XFree(vi);
g_egl_inited = true;
g_egl_inited = true;
if (!x11_input_ctx_new(true_full))
goto error;
@ -423,13 +434,11 @@ static bool gfx_ctx_xegl_has_windowed(void *data)
return true;
}
static bool gfx_ctx_xegl_bind_api(void *data,
static bool gfx_ctx_xegl_bind_api(void *video_driver,
enum gfx_ctx_api api, unsigned major, unsigned minor)
{
(void)data;
g_major = major;
g_minor = minor;
g_egl_major = major;
g_egl_minor = minor;
g_egl_api = api;
switch (api)

104
gfx/video_context_driver.c
View File

@ -98,25 +98,12 @@ void gfx_ctx_destroy(const gfx_ctx_driver_t *ctx_driver)
current_video_context = NULL;
}
void gfx_ctx_data_set(void *ptr)
{
if (!ptr)
return;
video_context_data = ptr;
}
void gfx_ctx_free_data(void)
{
if (video_context_data)
free(video_context_data);
video_context_data = NULL;
}
void gfx_ctx_free(void *data)
void gfx_ctx_free(void)
{
if (current_video_context->destroy)
current_video_context->destroy(data);
current_video_context->destroy(video_context_data);
current_video_context = NULL;
video_context_data = NULL;
}
const char *gfx_ctx_get_ident(void)
@ -128,78 +115,78 @@ const char *gfx_ctx_get_ident(void)
return ctx->ident;
}
void gfx_ctx_update_window_title(void *data)
void gfx_ctx_update_window_title(void)
{
if (current_video_context->update_window_title)
current_video_context->update_window_title(data);
current_video_context->update_window_title(video_context_data);
}
void gfx_ctx_get_video_output_size(void *data,
void gfx_ctx_get_video_output_size(
unsigned *width, unsigned *height)
{
const gfx_ctx_driver_t *ctx = current_video_context;
if (ctx->get_video_output_size)
ctx->get_video_output_size(data, width, height);
ctx->get_video_output_size(video_context_data, width, height);
}
bool gfx_ctx_get_video_output_prev(void *data)
bool gfx_ctx_get_video_output_prev(void)
{
if (current_video_context->get_video_output_prev)
{
current_video_context->get_video_output_prev(data);
current_video_context->get_video_output_prev(video_context_data);
return true;
}
return false;
}
bool gfx_ctx_get_video_output_next(void *data)
bool gfx_ctx_get_video_output_next(void)
{
if (current_video_context->get_video_output_next)
{
current_video_context->get_video_output_next(data);
current_video_context->get_video_output_next(video_context_data);
return true;
}
return false;
}
void gfx_ctx_swap_buffers(void *data)
void gfx_ctx_swap_buffers(void)
{
if (!current_video_context)
return;
if (current_video_context->swap_buffers)
current_video_context->swap_buffers(data);
current_video_context->swap_buffers(video_context_data);
}
void gfx_ctx_bind_hw_render(void *data, bool enable)
void gfx_ctx_bind_hw_render(bool enable)
{
if (current_video_context->bind_hw_render)
current_video_context->bind_hw_render(data, enable);
current_video_context->bind_hw_render(video_context_data, enable);
}
bool gfx_ctx_focus(void *data)
bool gfx_ctx_focus(void)
{
if (data && current_video_context->has_focus)
return current_video_context->has_focus(data);
if (video_context_data && current_video_context->has_focus)
return current_video_context->has_focus(video_context_data);
return false;
}
bool gfx_ctx_set_video_mode(void *data,
bool gfx_ctx_set_video_mode(
unsigned width, unsigned height,
bool fullscreen)
{
if (current_video_context->set_video_mode)
return current_video_context->set_video_mode(data, width, height, fullscreen);
return current_video_context->set_video_mode(video_context_data, width, height, fullscreen);
return false;
}
void gfx_ctx_translate_aspect(void *data, float *aspect,
void gfx_ctx_translate_aspect(float *aspect,
unsigned width, unsigned height)
{
if (current_video_context->translate_aspect)
*aspect = current_video_context->translate_aspect(data, width, height);
*aspect = current_video_context->translate_aspect(video_context_data, width, height);
}
bool gfx_ctx_get_metrics(enum display_metric_types type, float *value)
@ -234,64 +221,64 @@ retro_proc_address_t gfx_ctx_get_proc_address(const char *sym)
return current_video_context->get_proc_address(sym);
}
void gfx_ctx_show_mouse(void *data, bool state)
void gfx_ctx_show_mouse(bool state)
{
if (data && current_video_context->show_mouse)
current_video_context->show_mouse(data, state);
if (video_context_data && current_video_context->show_mouse)
current_video_context->show_mouse(video_context_data, state);
}
bool gfx_ctx_has_windowed(void *data)
bool gfx_ctx_has_windowed(void)
{
if (data)
return current_video_context->has_windowed(data);
if (video_context_data)
return current_video_context->has_windowed(video_context_data);
return true;
}
bool gfx_ctx_check_window(void *data, bool *quit, bool *resize,
bool gfx_ctx_check_window(bool *quit, bool *resize,
unsigned *width, unsigned *height)
{
uint64_t *frame_count;
video_driver_ctl(RARCH_DISPLAY_CTL_GET_FRAME_COUNT, &frame_count);
if (!data)
if (!video_context_data)
return false;
current_video_context->check_window(data, quit, resize, width, height, (unsigned int)*frame_count);
current_video_context->check_window(video_context_data, quit, resize, width, height, (unsigned int)*frame_count);
return true;
}
bool gfx_ctx_suppress_screensaver(void *data, bool enable)
bool gfx_ctx_suppress_screensaver(bool enable)
{
if (data && current_video_context)
return current_video_context->suppress_screensaver(data, enable);
if (video_context_data && current_video_context)
return current_video_context->suppress_screensaver(video_context_data, enable);
return false;
}
void gfx_ctx_get_video_size(void *data,
void gfx_ctx_get_video_size(
unsigned *width, unsigned *height)
{
current_video_context->get_video_size(data, width, height);
current_video_context->get_video_size(video_context_data, width, height);
}
void gfx_ctx_swap_interval(void *data, unsigned interval)
void gfx_ctx_swap_interval(unsigned interval)
{
if (current_video_context)
current_video_context->swap_interval(data, interval);
current_video_context->swap_interval(video_context_data, interval);
}
void gfx_ctx_set_resize(void *data, unsigned width, unsigned height)
void gfx_ctx_set_resize(unsigned width, unsigned height)
{
if (current_video_context)
current_video_context->set_resize(data, width, height);
current_video_context->set_resize(video_context_data, width, height);
}
void gfx_ctx_input_driver(void *data,
void gfx_ctx_input_driver(
const input_driver_t **input, void **input_data)
{
if (current_video_context)
current_video_context->input_driver(data, input, input_data);
current_video_context->input_driver(video_context_data, input, input_data);
}
/**
@ -375,15 +362,16 @@ static const gfx_ctx_driver_t *gfx_ctx_init(void *data,
if (ctx->bind_api(data, api, major, minor))
{
bool initialized = ctx->init(data);
void *ctx_data = ctx->init(data);
if (!initialized)
if (!ctx_data)
return NULL;
if (ctx->bind_hw_render)
ctx->bind_hw_render(data,
ctx->bind_hw_render(ctx_data,
settings->video.shared_context && hw_render_ctx);
video_context_data = ctx_data;
return ctx;
}

61
gfx/video_context_driver.h
View File

@ -53,21 +53,18 @@ enum display_metric_types
typedef void (*gfx_ctx_proc_t)(void);
/* The opaque void* argument should be the overlying driver data
* (e.g. gl_t for OpenGL contexts).
*
* This will allow us in the future to have separate contexts
* to separate gl_t structs (if needed).
*
* For now, this is only relevant for D3D. */
typedef struct gfx_ctx_driver
{
bool (*init)(void *data);
/* The opaque pointer is the underlying video driver data (e.g. gl_t for
* OpenGL contexts). Although not advised, the context driver is allowed
* to hold a pointer to it as the context never outlives the video driver.
*
* The context driver is responsible for it's own data.*/
void* (*init)(void *video_driver);
void (*destroy)(void *data);
/* Which API to bind to. */
bool (*bind_api)(void *data, enum gfx_ctx_api,
bool (*bind_api)(void *video_driver, enum gfx_ctx_api,
unsigned major, unsigned minor);
/* Sets the swap interval. */
@ -203,16 +200,15 @@ void find_prev_gfx_context_driver(void);
bool gfx_ctx_get_metrics(enum display_metric_types type, float *value);
void gfx_ctx_translate_aspect(void *data, float *aspect,
void gfx_ctx_translate_aspect(float *aspect,
unsigned width, unsigned height);
bool gfx_ctx_set_video_mode(void *data,
unsigned width, unsigned height,
bool gfx_ctx_set_video_mode(unsigned width, unsigned height,
bool fullscreen);
void gfx_ctx_swap_buffers(void *data);
void gfx_ctx_swap_buffers(void);
bool gfx_ctx_focus(void *data);
bool gfx_ctx_focus(void);
bool gfx_ctx_image_buffer_init(void *data, const video_info_t *info);
@ -220,47 +216,42 @@ bool gfx_ctx_image_buffer_write(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch, bool rgb32,
unsigned index, void **image_handle);
void gfx_ctx_show_mouse(void *data, bool state);
void gfx_ctx_show_mouse(bool state);
bool gfx_ctx_has_windowed(void *data);
bool gfx_ctx_has_windowed(void);
bool gfx_ctx_check_window(void *data, bool *quit, bool *resize,
bool gfx_ctx_check_window(bool *quit, bool *resize,
unsigned *width, unsigned *height);
bool gfx_ctx_suppress_screensaver(void *data, bool enable);
bool gfx_ctx_suppress_screensaver(bool enable);
void gfx_ctx_update_window_title(void *data);
void gfx_ctx_update_window_title(void);
void gfx_ctx_get_video_size(void *data, unsigned *width, unsigned *height);
void gfx_ctx_get_video_size(unsigned *width, unsigned *height);
void gfx_ctx_set_resize(void *data, unsigned width, unsigned height);
void gfx_ctx_set_resize(unsigned width, unsigned height);
void gfx_ctx_swap_interval(void *data, unsigned interval);
void gfx_ctx_swap_interval(unsigned interval);
void gfx_ctx_bind_hw_render(void *data, bool enable);
void gfx_ctx_bind_hw_render(bool enable);
void gfx_ctx_get_video_output_size(void *data,
unsigned *width, unsigned *height);
void gfx_ctx_get_video_output_size(unsigned *width, unsigned *height);
bool gfx_ctx_get_video_output_prev(void *data);
bool gfx_ctx_get_video_output_prev(void);
bool gfx_ctx_get_video_output_next(void *data);
bool gfx_ctx_get_video_output_next(void);
const char *gfx_ctx_get_ident(void);
void gfx_ctx_free(void *data);
void gfx_ctx_free(void);
void gfx_ctx_input_driver(void *data,
const input_driver_t **input, void **input_data);
void gfx_ctx_input_driver(
const input_driver_t **input, void **input_data);
retro_proc_address_t gfx_ctx_get_proc_address(const char *sym);
void *gfx_ctx_data_get_ptr(void);
void gfx_ctx_data_set(void *ptr);
void gfx_ctx_free_data(void);
void gfx_ctx_set(const gfx_ctx_driver_t *ctx_driver);
void gfx_ctx_destroy(const gfx_ctx_driver_t *ctx_driver);

6
gfx/video_driver.c
View File

@ -797,7 +797,7 @@ bool video_driver_set_video_mode(unsigned width,
return true;
}
return gfx_ctx_set_video_mode(gfx_ctx_data_get_ptr(), width, height, fullscreen);
return gfx_ctx_set_video_mode(width, height, fullscreen);
}
bool video_driver_get_video_output_size(unsigned *width, unsigned *height)
@ -1485,7 +1485,7 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
video_driver_poke->get_video_output_next(video_driver_data);
return true;
}
return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr());
return gfx_ctx_get_video_output_next();
case RARCH_DISPLAY_CTL_GET_PREV_VIDEO_OUT:
if (!video_driver_poke)
return false;
@ -1495,7 +1495,7 @@ bool video_driver_ctl(enum rarch_display_ctl_state state, void *data)
video_driver_poke->get_video_output_prev(video_driver_data);
return true;
}
return gfx_ctx_get_video_output_next(gfx_ctx_data_get_ptr());
return gfx_ctx_get_video_output_next();
case RARCH_DISPLAY_CTL_INIT:
return init_video();
case RARCH_DISPLAY_CTL_DESTROY_DATA: