CTCaer/RetroArch
1
0
Fork 0
mirror of https://github.com/CTCaer/RetroArch.git synced 2024-12-13 13:28:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename video context driver functions

Browse Source
This commit is contained in:
twinaphex 2016-05-08 20:32:46 +02:00
parent be1daeebd7
commit b20d550cc4
13 changed files with 440 additions and 397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dynamic.c
View File

@ -976,7 +976,7 @@ bool rarch_environment_cb(unsigned cmd, void *data)
flags.flags = 0;
BIT32_SET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);
gfx_ctx_ctl(GFX_CTL_SET_FLAGS, &flags);
video_context_driver_set_flags(&flags);
RARCH_LOG("Requesting core OpenGL context (%u.%u).\n",
cb->version_major, cb->version_minor);

36
gfx/d3d/d3d.cpp
View File

@ -544,7 +544,7 @@ void d3d_make_d3dpp(void *data,
unsigned width = 0;
unsigned height = 0;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
width = mode.width;
height = mode.height;
@ -664,7 +664,7 @@ static void d3d_calculate_rect(void *data,
aspect_data.width = *width;
aspect_data.height = *height;
gfx_ctx_ctl(GFX_CTL_TRANSLATE_ASPECT, &aspect_data);
video_context_driver_translate_aspect(&aspect_data);
*x = 0;
*y = 0;
@ -845,7 +845,7 @@ static void d3d_set_nonblock_state(void *data, bool state)
d3d->video_info.vsync = !state;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_swap_interval(&interval);
#ifndef _XBOX
d3d->needs_restore = true;
d3d_restore(d3d);
@ -867,7 +867,7 @@ static bool d3d_alive(void *data)
size_data.width = &temp_width;
size_data.height = &temp_height;
if (gfx_ctx_ctl(GFX_CTL_CHECK_WINDOW, &size_data))
if (video_context_driver_check_window(&size_data))
{
if (quit)
d3d->quitting = quit;
@ -881,7 +881,7 @@ static bool d3d_alive(void *data)
mode.width = temp_width;
mode.height = temp_height;
gfx_ctx_ctl(GFX_CTL_SET_RESIZE, &mode);
video_context_driver_set_resize(&mode);
d3d_restore(d3d);
}
@ -896,18 +896,18 @@ static bool d3d_alive(void *data)
static bool d3d_focus(void *data)
{
return gfx_ctx_ctl(GFX_CTL_FOCUS, NULL);
return video_context_driver_focus();
}
static bool d3d_suppress_screensaver(void *data, bool enable)
{
bool enabled = enable;
return gfx_ctx_ctl(GFX_CTL_SUPPRESS_SCREENSAVER, &enabled);
return video_context_driver_suppress_screensaver(&enabled);
}
static bool d3d_has_windowed(void *data)
{
return gfx_ctx_ctl(GFX_CTL_HAS_WINDOWED, NULL);
return video_context_driver_has_windowed();
}
static void d3d_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
@ -1017,7 +1017,7 @@ static bool d3d_construct(d3d_video_t *d3d,
{
gfx_ctx_mode_t mode;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
@ -1065,7 +1065,7 @@ static bool d3d_construct(d3d_video_t *d3d,
inp.input = input;
inp.input_data = input_data;
gfx_ctx_ctl(GFX_CTL_INPUT_DRIVER, &inp);
video_context_driver_input_driver(&inp);
RARCH_LOG("[D3D]: Init complete.\n");
return true;
@ -1084,7 +1084,7 @@ static void d3d_set_rotation(void *data, unsigned rot)
static void d3d_show_mouse(void *data, bool state)
{
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &state);
video_context_driver_show_mouse(&state);
}
static const gfx_ctx_driver_t *d3d_get_context(void *data)
@ -1100,7 +1100,7 @@ static const gfx_ctx_driver_t *d3d_get_context(void *data)
unsigned major = 9;
enum gfx_ctx_api api = GFX_CTX_DIRECT3D9_API;
#endif
return video_driver_context_init_first(data,
return video_context_driver_init_first(data,
settings->video.context_driver,
api, major, minor, false);
}
@ -1154,7 +1154,7 @@ static void *d3d_init(const video_info_t *info,
#endif
#endif
gfx_ctx_ctl(GFX_CTL_SET, (void*)ctx_driver);
video_context_driver_set((void*)ctx_driver);
if (!d3d_construct(d3d, info, input, input_data))
{
@ -1171,7 +1171,7 @@ static void *d3d_init(const video_info_t *info,
return d3d;
error:
gfx_ctx_ctl(GFX_CTL_DESTROY, NULL);
video_context_driver_destroy();
if (d3d)
delete d3d;
return NULL;
@ -1204,7 +1204,7 @@ static void d3d_free(void *data)
d3d_free_overlays(d3d);
#endif
gfx_ctx_ctl(GFX_CTL_FREE, NULL);
video_context_driver_free();
#ifndef _XBOX
#ifdef HAVE_MENU
@ -1392,7 +1392,7 @@ static void d3d_overlay_enable(void *data, bool state)
for (i = 0; i < d3d->overlays.size(); i++)
d3d->overlays_enabled = state;
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &state);
video_context_driver_show_mouse(&state);
}
static void d3d_overlay_full_screen(void *data, bool enable)
@ -1537,11 +1537,11 @@ static bool d3d_frame(void *data, const void *frame,
}
#endif
gfx_ctx_ctl(GFX_CTL_UPDATE_WINDOW_TITLE, NULL);
video_context_driver_update_window_title();
retro_perf_stop(&d3d_frame);
gfx_ctx_ctl(GFX_CTL_SWAP_BUFFERS, NULL);
video_context_driver_swap_buffers();
return true;
}

59
gfx/drivers/gl.c
View File

@ -115,7 +115,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_ctl(GFX_CTL_BIND_HW_RENDER, &enable);
video_context_driver_bind_hw_render(&enable);
}
static INLINE bool gl_query_extension(gl_t *gl, const char *ext)
@ -882,7 +882,7 @@ static void gl_set_viewport(void *data, unsigned viewport_width,
aspect_data.width = viewport_width;
aspect_data.height = viewport_height;
gfx_ctx_ctl(GFX_CTL_TRANSLATE_ASPECT, &aspect_data);
video_context_driver_translate_aspect(&aspect_data);
if (settings->video.scale_integer && !force_full)
{
@ -987,7 +987,7 @@ static void gl_set_video_mode(void *data, unsigned width, unsigned height,
mode.height = height;
mode.fullscreen = fullscreen;
gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode);
video_context_driver_set_video_mode(&mode);
}
#ifdef HAVE_FBO
@ -1387,7 +1387,7 @@ static void gl_init_textures(gl_t *gl, const video_info_t *video)
#if defined(HAVE_EGL) && defined(HAVE_OPENGLES2)
/* Use regular textures if we use HW render. */
gl->egl_images = !gl->hw_render_use && gl_check_eglimage_proc() &&
gfx_ctx_ctl(GFX_CTL_IMAGE_BUFFER_INIT, (void*)video);
video_context_driver_init_image_buffer((void*)video);
#else
(void)video;
#endif
@ -1466,7 +1466,7 @@ static INLINE void gl_copy_frame(gl_t *gl, const void *frame,
img_info.rgb32 = (gl->base_size == 4);
img_info.handle = &img;
new_egl = gfx_ctx_ctl(GFX_CTL_IMAGE_BUFFER_WRITE, &img_info);
new_egl = video_context_driver_write_to_image_buffer(&img_info);
if (img == EGL_NO_IMAGE_KHR)
{
@ -1793,7 +1793,7 @@ static bool gl_frame(void *data, const void *frame,
mode.width = width;
mode.height = height;
gfx_ctx_ctl(GFX_CTL_SET_RESIZE, &mode);
video_context_driver_set_resize(&mode);
#ifdef HAVE_FBO
if (gl->fbo_inited)
@ -1938,7 +1938,7 @@ static bool gl_frame(void *data, const void *frame,
gl_render_overlay(gl);
#endif
gfx_ctx_ctl(GFX_CTL_UPDATE_WINDOW_TITLE, NULL);
video_context_driver_update_window_title();
retro_perf_stop(&frame_run);
@ -1989,11 +1989,11 @@ static bool gl_frame(void *data, const void *frame,
&& !runloop_ctl(RUNLOOP_CTL_IS_SLOWMOTION, NULL)
&& !runloop_ctl(RUNLOOP_CTL_IS_PAUSED, NULL))
{
gfx_ctx_ctl(GFX_CTL_SWAP_BUFFERS, NULL);
video_context_driver_swap_buffers();
glClear(GL_COLOR_BUFFER_BIT);
}
gfx_ctx_ctl(GFX_CTL_SWAP_BUFFERS, NULL);
video_context_driver_swap_buffers();
#ifdef HAVE_GL_SYNC
if (settings->video.hard_sync && gl->have_sync)
@ -2121,7 +2121,7 @@ static void gl_free(void *data)
}
#endif
gfx_ctx_ctl(GFX_CTL_FREE, NULL);
video_context_driver_free();
free(gl->empty_buf);
free(gl->conv_buffer);
@ -2144,7 +2144,7 @@ static void gl_set_nonblock_state(void *data, bool state)
if (!state)
interval = settings->video.swap_interval;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_swap_interval(&interval);
context_bind_hw_render(gl, true);
}
@ -2444,7 +2444,7 @@ static const gfx_ctx_driver_t *gl_get_context(gl_t *gl)
gl->shared_context_use = settings->video.shared_context
&& hwr->context_type != RETRO_HW_CONTEXT_NONE;
return video_driver_context_init_first(gl, settings->video.context_driver,
return video_context_driver_init_first(gl, settings->video.context_driver,
api, major, minor, gl->shared_context_use);
}
@ -2610,13 +2610,13 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
if (!gl || !ctx_driver)
goto error;
gfx_ctx_ctl(GFX_CTL_SET, (void*)ctx_driver);
video_context_driver_set((void*)ctx_driver);
gl->video_info = *video;
RARCH_LOG("Found GL context: %s\n", ctx_driver->ident);
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
@ -2627,7 +2627,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
interval = video->vsync ? settings->video.swap_interval : 0;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_swap_interval(&interval);
win_width = video->width;
win_height = video->height;
@ -2642,7 +2642,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
mode.height = win_height;
mode.fullscreen = video->fullscreen;
if (!gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode))
if (!video_context_driver_set_video_mode(&mode))
goto error;
/* Clear out potential error flags in case we use cached context. */
@ -2678,7 +2678,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
mode.width = 0;
mode.height = 0;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
@ -2832,7 +2832,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
inp.input = input;
inp.input_data = input_data;
gfx_ctx_ctl(GFX_CTL_INPUT_DRIVER, &inp);
video_context_driver_input_driver(&inp);
if (settings->video.font_enable)
{
@ -2853,7 +2853,7 @@ static void *gl_init(const video_info_t *video, const input_driver_t **input, vo
return gl;
error:
gfx_ctx_ctl(GFX_CTL_DESTROY, NULL);
video_context_driver_destroy();
free(gl);
return NULL;
}
@ -2876,7 +2876,7 @@ static bool gl_alive(void *data)
size_data.width = &temp_width;
size_data.height = &temp_height;
if (gfx_ctx_ctl(GFX_CTL_CHECK_WINDOW, &size_data))
if (video_context_driver_check_window(&size_data))
{
if (quit)
gl->quitting = true;
@ -2894,18 +2894,18 @@ static bool gl_alive(void *data)
static bool gl_focus(void *data)
{
return gfx_ctx_ctl(GFX_CTL_FOCUS, NULL);
return video_context_driver_focus();
}
static bool gl_suppress_screensaver(void *data, bool enable)
{
bool enabled = enable;
return gfx_ctx_ctl(GFX_CTL_SUPPRESS_SCREENSAVER, &enabled);
return video_context_driver_suppress_screensaver(&enabled);
}
static bool gl_has_windowed(void *data)
{
return gfx_ctx_ctl(GFX_CTL_HAS_WINDOWED, NULL);
return video_context_driver_has_windowed();
}
static void gl_update_tex_filter_frame(gl_t *gl)
@ -3463,7 +3463,7 @@ static void gl_overlay_enable(void *data, bool state)
gl->overlay_enable = state;
if (gl->fullscreen)
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &state);
video_context_driver_show_mouse(&state);
}
static void gl_overlay_full_screen(void *data, bool enable)
@ -3579,7 +3579,7 @@ static retro_proc_address_t gl_get_proc_address(void *data, const char *sym)
proc_address.sym = sym;
gfx_ctx_ctl(GFX_CTL_PROC_ADDRESS_GET, &proc_address);
video_context_driver_get_proc_address(&proc_address);
return proc_address.addr;
}
@ -3677,7 +3677,7 @@ static void gl_set_osd_msg(void *data, const char *msg,
static void gl_show_mouse(void *data, bool state)
{
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &state);
video_context_driver_show_mouse(&state);
}
static struct video_shader *gl_get_current_shader(void *data)
@ -3696,20 +3696,19 @@ static void gl_get_video_output_size(void *data,
gfx_ctx_size_t size_data;
size_data.width = width;
size_data.height = height;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_OUTPUT_SIZE, &size_data);
video_context_driver_get_video_output_size(&size_data);
}
static void gl_get_video_output_prev(void *data)
{
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_OUTPUT_PREV, NULL);
video_context_driver_get_video_output_prev();
}
static void gl_get_video_output_next(void *data)
{
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_OUTPUT_NEXT, NULL);
video_context_driver_get_video_output_next();
}
static void video_texture_load_gl(
struct texture_image *ti,
enum texture_filter_type filter_type,

42
gfx/drivers/vg.c
View File

@ -70,7 +70,7 @@ static PFNVGCREATEEGLIMAGETARGETKHRPROC pvgCreateEGLImageTargetKHR;
static void vg_set_nonblock_state(void *data, bool state)
{
unsigned interval = state ? 0 : 1;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_set_swap_interval(&interval);
}
static INLINE bool vg_query_extension(const char *ext)
@ -94,16 +94,16 @@ static void *vg_init(const video_info_t *video,
VGfloat clearColor[4] = {0, 0, 0, 1};
settings_t *settings = config_get_ptr();
vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t));
const gfx_ctx_driver_t *ctx = video_driver_context_init_first(
const gfx_ctx_driver_t *ctx = video_context_driver_init_first(
vg, settings->video.context_driver,
GFX_CTX_OPENVG_API, 0, 0, false);
if (!vg || !ctx)
goto error;
gfx_ctx_ctl(GFX_CTL_SET, (void*)ctx);
video_context_driver_set((void*)ctx);
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
@ -117,8 +117,8 @@ static void *vg_init(const video_info_t *video,
interval = video->vsync ? 1 : 0;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
gfx_ctx_ctl(GFX_CTL_UPDATE_WINDOW_TITLE, NULL);
video_context_driver_swap_interval(&interval);
video_context_driver_update_window_title();
vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
vg->keep_aspect = video->force_aspect;
@ -137,7 +137,7 @@ static void *vg_init(const video_info_t *video,
mode.height = win_height;
mode.fullscreen = video->fullscreen;
if (!gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode))
if (!vidoe_context_driver_set_video_mode(&mode))
goto error;
video_driver_get_size(&temp_width, &temp_height);
@ -147,7 +147,7 @@ static void *vg_init(const video_info_t *video,
mode.width = 0;
mode.height = 0;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
@ -170,7 +170,7 @@ static void *vg_init(const video_info_t *video,
aspect_data.width = temp_width;
aspect_data.height = temp_height;
gfx_ctx_ctl(GFX_CTL_TRANSLATE_ASPECT, &aspect_data);
video_context_driver_translate_aspect(&aspect_data);
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
@ -182,7 +182,7 @@ static void *vg_init(const video_info_t *video,
inp.input = input;
inp.input_data = input_data;
gfx_ctx_ctl(GFX_CTL_INPUT_DRIVER, &inp);
video_context_driver_input_driver(&inp);
if ( settings->video.font_enable
&& font_renderer_create_default((const void**)&vg->font_driver, &vg->mFontRenderer,
@ -216,13 +216,13 @@ static void *vg_init(const video_info_t *video,
}
if (vg_query_extension("KHR_EGL_image")
&& gfx_ctx_ctl(GFX_CTL_IMAGE_BUFFER_INIT, (void*)video))
&& video_context_driver_init_image_buffer((void*)video))
{
gfx_ctx_proc_address_t proc_address;
proc_address.sym = "vgCreateEGLImageTargetKHR";
gfx_ctx_ctl(GFX_CTL_PROC_ADDRESS_GET, &proc_address);
video_context_driver_get_proc_address(&proc_address);
pvgCreateEGLImageTargetKHR =
(PFNVGCREATEEGLIMAGETARGETKHRPROC)proc_address.addr;
@ -245,7 +245,7 @@ static void *vg_init(const video_info_t *video,
error:
if (vg)
free(vg);
gfx_ctx_ctl(GFX_CTL_DESTROY, NULL);
video_context_driver_destroy();
return NULL;
}
@ -266,7 +266,7 @@ static void vg_free(void *data)
vgDestroyPaint(vg->mPaintBg);
}
gfx_ctx_ctl(GFX_CTL_FREE, NULL);
video_context_driver_free();
free(vg);
}
@ -343,7 +343,7 @@ static void vg_copy_frame(void *data, const void *frame,
img_info.index = 0;
img_info.handle = &img;
new_egl = gfx_ctx_ctl(GFX_CTL_IMAGE_BUFFER_WRITE, &img_info);
new_egl = video_context_driver_write_to_image_buffer(&img_info);
retro_assert(img != EGL_NO_IMAGE_KHR);
@ -413,11 +413,11 @@ static bool vg_frame(void *data, const void *frame,
vg_draw_message(vg, msg);
#endif
gfx_ctx_ctl(GFX_CTL_UPDATE_WINDOW_TITLE, NULL);
video_context_driver_update_window_title();
retro_perf_stop(&vg_fr);
gfx_ctx_ctl(GFX_CTL_SWAP_BUFFERS, NULL);
video_context_driver_swap_buffers();
return true;
}
@ -435,7 +435,7 @@ static bool vg_alive(void *data)
size_data.width = &temp_width;
size_data.height = &temp_height;
gfx_ctx_ctl(GFX_CTL_CHECK_WINDOW, &size_data);
video_context_driver_check_window(&size_data);
if (temp_width != 0 && temp_height != 0)
video_driver_set_size(&temp_width, &temp_height);
@ -445,18 +445,18 @@ static bool vg_alive(void *data)
static bool vg_focus(void *data)
{
return gfx_ctx_ctl(GFX_CTL_FOCUS, NULL);
return video_context_driver_focus();
}
static bool vg_suppress_screensaver(void *data, bool enable)
{
bool enabled = enable;
return gfx_ctx_ctl(GFX_CTL_SUPPRESS_SCREENSAVER, &enabled);
return video_context_driver_suppress_screensaver(&enabled);
}
static bool vg_has_windowed(void *data)
{
return gfx_ctx_ctl(GFX_CTL_HAS_WINDOWED, NULL);
return video_context_driver_has_windowed();
}
static bool vg_set_shader(void *data,

42
gfx/drivers/vulkan.c
View File

@ -70,7 +70,7 @@ static const gfx_ctx_driver_t *vulkan_get_context(vk_t *vk)
settings_t *settings = config_get_ptr();
enum gfx_ctx_api api = GFX_CTX_VULKAN_API;
return video_driver_context_init_first(
return video_context_driver_init_first(
vk, settings->video.context_driver,
api, major, minor, false);
}
@ -810,7 +810,7 @@ static void vulkan_free(void *data)
if (vk->filter_chain)
vulkan_filter_chain_free(vk->filter_chain);
gfx_ctx_ctl(GFX_CTL_FREE, NULL);
video_context_driver_free();
}
scaler_ctx_gen_reset(&vk->readback.scaler);
@ -980,9 +980,9 @@ static void *vulkan_init(const video_info_t *video,
if (!ctx_driver)
goto error;
gfx_ctx_ctl(GFX_CTL_SET, (void*)ctx_driver);
video_context_driver_set((void*)ctx_driver);
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
full_x = mode.width;
full_y = mode.height;
mode.width = 0;
@ -990,7 +990,7 @@ static void *vulkan_init(const video_info_t *video,
RARCH_LOG("Detecting screen resolution %ux%u.\n", full_x, full_y);
interval = video->vsync ? settings->video.swap_interval : 0;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_swap_interval(&interval);
win_width = video->width;
win_height = video->height;
@ -1004,10 +1004,10 @@ static void *vulkan_init(const video_info_t *video,
mode.width = win_width;
mode.height = win_height;
mode.fullscreen = video->fullscreen;
if (!gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode))
if (!video_context_driver_set_video_mode(&mode))
goto error;
gfx_ctx_ctl(GFX_CTL_GET_VIDEO_SIZE, &mode);
video_context_driver_get_video_size(&mode);
temp_width = mode.width;
temp_height = mode.height;
@ -1017,7 +1017,7 @@ static void *vulkan_init(const video_info_t *video,
RARCH_LOG("Vulkan: Using resolution %ux%u\n", temp_width, temp_height);
gfx_ctx_ctl(GFX_CTL_GET_CONTEXT_DATA, &vk->context);
video_context_driver_get_context_data(&vk->context);
vk->vsync = video->vsync;
vk->fullscreen = video->fullscreen;
@ -1041,7 +1041,7 @@ static void *vulkan_init(const video_info_t *video,
inp.input = input;
inp.input_data = input_data;
gfx_ctx_ctl(GFX_CTL_INPUT_DRIVER, &inp);
video_context_driver_input_driver(&inp);
if (settings->video.font_enable)
{
@ -1098,7 +1098,7 @@ static void vulkan_set_nonblock_state(void *data, bool state)
RARCH_LOG("[Vulkan]: VSync => %s\n", state ? "off" : "on");
interval = state ? 0 : settings->video.swap_interval;
gfx_ctx_ctl(GFX_CTL_SWAP_INTERVAL, &interval);
video_context_driver_swap_interval(&interval);
/* Changing vsync might require recreating the swapchain, which means new VkImages
* to render into. */
@ -1122,7 +1122,7 @@ static bool vulkan_alive(void *data)
size_data.width = &temp_width;
size_data.height = &temp_height;
if (gfx_ctx_ctl(GFX_CTL_CHECK_WINDOW, &size_data))
if (video_context_driver_check_window(&size_data))
{
if (quit)
vk->quitting = true;
@ -1141,20 +1141,20 @@ static bool vulkan_alive(void *data)
static bool vulkan_focus(void *data)
{
(void)data;
return gfx_ctx_ctl(GFX_CTL_FOCUS, NULL);
return video_context_driver_focus();
}
static bool vulkan_suppress_screensaver(void *data, bool enable)
{
(void)data;
bool enabled = enable;
return gfx_ctx_ctl(GFX_CTL_SUPPRESS_SCREENSAVER, &enabled);
return video_context_driver_suppress_screensaver(&enabled);
}
static bool vulkan_has_windowed(void *data)
{
(void)data;
return gfx_ctx_ctl(GFX_CTL_HAS_WINDOWED, NULL);
return video_context_driver_has_windowed();
}
static bool vulkan_set_shader(void *data,
@ -1232,7 +1232,7 @@ static void vulkan_set_video_mode(void *data,
mode.height = height;
mode.fullscreen = fullscreen;
gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode);
video_context_driver_set_video_mode(&mode);
}
static void vulkan_set_viewport(void *data, unsigned viewport_width,
@ -1253,7 +1253,7 @@ static void vulkan_set_viewport(void *data, unsigned viewport_width,
aspect_data.width = viewport_width;
aspect_data.height = viewport_height;
gfx_ctx_ctl(GFX_CTL_TRANSLATE_ASPECT, &aspect_data);
video_context_driver_translate_aspect(&aspect_data);
if (settings->video.scale_integer && !force_full)
{
@ -1747,10 +1747,10 @@ static bool vulkan_frame(void *data, const void *frame,
retro_perf_stop(&queue_submit);
retro_perf_start(&swapbuffers);
gfx_ctx_ctl(GFX_CTL_SWAP_BUFFERS, NULL);
video_context_driver_swap_buffers();
retro_perf_stop(&swapbuffers);
gfx_ctx_ctl(GFX_CTL_UPDATE_WINDOW_TITLE, NULL);
video_context_driver_update_window_title();
/* Handle spurious swapchain invalidations as soon as we can,
* i.e. right after swap buffers. */
@ -1759,7 +1759,7 @@ static bool vulkan_frame(void *data, const void *frame,
gfx_ctx_mode_t mode;
mode.width = width;
mode.height = height;
gfx_ctx_ctl(GFX_CTL_SET_RESIZE, &mode);
video_context_driver_set_resize(&mode);
vk->should_resize = false;
}
@ -1810,7 +1810,7 @@ static void vulkan_apply_state_changes(void *data)
static void vulkan_show_mouse(void *data, bool state)
{
(void)data;
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &state);
video_context_driver_show_mouse(&state);
}
static struct video_shader *vulkan_get_current_shader(void *data)
@ -2117,7 +2117,7 @@ static void vulkan_overlay_enable(void *data, bool enable)
vk->overlay.enable = enable;
if (vk->fullscreen)
gfx_ctx_ctl(GFX_CTL_SHOW_MOUSE, &enable);
video_context_driver_show_mouse(&enable);
}
static void vulkan_overlay_full_screen(void *data, bool enable)

1
gfx/drivers_context/vc_egl_ctx.c
View File

@ -469,7 +469,6 @@ static float gfx_ctx_vc_translate_aspect(void *data,
unsigned width, unsigned height)
{
(void)data;
/* Check for SD televisions: they should always be 4:3. */
if ((width == 640 || width == 720) && (height == 480 || height == 576))
return 4.0f / 3.0f;

531
gfx/video_context_driver.c
View File

@ -89,7 +89,7 @@ static const gfx_ctx_driver_t *current_video_context = NULL;
static void *video_context_data = NULL;
/**
* find_video_driver_context_driver_index:
* find_video_context_driver_driver_index:
* @ident : Identifier of resampler driver to find.
*
* Finds graphics context driver index by @ident name.
@ -97,7 +97,7 @@ static void *video_context_data = NULL;
* Returns: graphics context driver index if driver was found, otherwise
* -1.
**/
static int find_video_driver_context_index(const char *ident)
static int find_video_context_driver_index(const char *ident)
{
unsigned i;
for (i = 0; gfx_ctx_drivers[i]; i++)
@ -111,10 +111,10 @@ static int find_video_driver_context_index(const char *ident)
*
* Finds previous driver in graphics context driver array.
**/
static bool video_driver_context_find_prev_driver(void)
bool video_context_driver_find_prev_driver(void)
{
settings_t *settings = config_get_ptr();
int i = find_video_driver_context_index(
int i = find_video_context_driver_index(
settings->video.context_driver);
if (i > 0)
@ -134,10 +134,10 @@ static bool video_driver_context_find_prev_driver(void)
*
* Finds next driver in graphics context driver array.
**/
static bool video_driver_context_find_next_driver(void)
bool video_context_driver_find_next_driver(void)
{
settings_t *settings = config_get_ptr();
int i = find_video_driver_context_index(settings->video.context_driver);
int i = find_video_context_driver_index(settings->video.context_driver);
if (i >= 0 && gfx_ctx_drivers[i + 1])
{
@ -152,7 +152,7 @@ static bool video_driver_context_find_next_driver(void)
}
/**
* video_driver_context_init:
* video_context_driver_init:
* @data : Input data.
* @ctx : Graphics context driver to initialize.
* @ident : Identifier of graphics context driver to find.
@ -166,7 +166,7 @@ static bool video_driver_context_find_next_driver(void)
*
* Returns: graphics context driver if successfully initialized, otherwise NULL.
**/
static const gfx_ctx_driver_t *video_driver_context_init(
static const gfx_ctx_driver_t *video_context_driver_init(
void *data,
const gfx_ctx_driver_t *ctx,
const char *ident,
@ -186,7 +186,7 @@ static const gfx_ctx_driver_t *video_driver_context_init(
ctx->bind_hw_render(ctx_data,
settings->video.shared_context && hw_render_ctx);
gfx_ctx_ctl(GFX_CTL_SET_VIDEO_CONTEXT_DATA, ctx_data);
video_context_driver_set_data(ctx_data);
return ctx;
}
@ -199,7 +199,7 @@ static const gfx_ctx_driver_t *video_driver_context_init(
}
/**
* video_driver_context_find_driver:
* video_context_driver_find_driver:
* @data : Input data.
* @ident : Identifier of graphics context driver to find.
* @api : API of higher-level graphics API.
@ -212,21 +212,21 @@ static const gfx_ctx_driver_t *video_driver_context_init(
*
* Returns: graphics context driver if found, otherwise NULL.
**/
static const gfx_ctx_driver_t *video_driver_context_find_driver(void *data,
static const gfx_ctx_driver_t *video_context_driver_find_driver(void *data,
const char *ident,
enum gfx_ctx_api api, unsigned major,
unsigned minor, bool hw_render_ctx)
{
int i = find_video_driver_context_index(ident);
int i = find_video_context_driver_index(ident);
if (i >= 0)
return video_driver_context_init(data, gfx_ctx_drivers[i], ident,
return video_context_driver_init(data, gfx_ctx_drivers[i], ident,
api, major, minor, hw_render_ctx);
for (i = 0; gfx_ctx_drivers[i]; i++)
{
const gfx_ctx_driver_t *ctx =
video_driver_context_init(data, gfx_ctx_drivers[i], ident,
video_context_driver_init(data, gfx_ctx_drivers[i], ident,
api, major, minor, hw_render_ctx);
if (ctx)
@ -237,7 +237,7 @@ static const gfx_ctx_driver_t *video_driver_context_find_driver(void *data,
}
/**
* video_driver_context_init_first:
* video_context_driver_init_first:
* @data : Input data.
* @ident : Identifier of graphics context driver to find.
* @api : API of higher-level graphics API.
@ -250,257 +250,280 @@ static const gfx_ctx_driver_t *video_driver_context_find_driver(void *data,
*
* Returns: graphics context driver if found, otherwise NULL.
**/
const gfx_ctx_driver_t *video_driver_context_init_first(void *data,
const gfx_ctx_driver_t *video_context_driver_init_first(void *data,
const char *ident, enum gfx_ctx_api api, unsigned major,
unsigned minor, bool hw_render_ctx)
{
return video_driver_context_find_driver(data, ident, api,
return video_context_driver_find_driver(data, ident, api,
major, minor, hw_render_ctx);
}
bool gfx_ctx_ctl(enum gfx_ctx_ctl_state state, void *data)
bool video_context_driver_check_window(gfx_ctx_size_t *size_data)
{
uint64_t *frame_count = NULL;
frame_count = video_driver_get_frame_count_ptr();
switch (state)
{
case GFX_CTL_CHECK_WINDOW:
{
uint64_t *frame_count = NULL;
gfx_ctx_size_t *size_data = (gfx_ctx_size_t*)data;
frame_count = video_driver_get_frame_count_ptr();
if (!video_context_data || !size_data)
return false;
if (!current_video_context || !current_video_context->check_window)
return false;
if (!video_context_data || !size_data)
return false;
if (!current_video_context || !current_video_context->check_window)
return false;
current_video_context->check_window(video_context_data,
size_data->quit,
size_data->resize,
size_data->width,
size_data->height, (unsigned int)*frame_count);
return true;
}
current_video_context->check_window(video_context_data,
size_data->quit,
size_data->resize,
size_data->width,
size_data->height, (unsigned int)*frame_count);
}
break;
case GFX_CTL_FIND_PREV_DRIVER:
if (!video_driver_context_find_prev_driver())
return false;
break;
case GFX_CTL_FIND_NEXT_DRIVER:
if (!video_driver_context_find_next_driver())
return false;
break;
case GFX_CTL_IMAGE_BUFFER_INIT:
if (!current_video_context || !current_video_context->image_buffer_init)
return false;
if (!current_video_context->image_buffer_init(video_context_data,
(const video_info_t*)data))
return false;
break;
case GFX_CTL_IMAGE_BUFFER_WRITE:
{
gfx_ctx_image_t *img = (gfx_ctx_image_t*)data;
bool video_context_driver_init_image_buffer(const video_info_t *data)
{
if (!current_video_context || !current_video_context->image_buffer_init)
return false;
if (!current_video_context->image_buffer_init(video_context_data, data))
return false;
return true;
}
if (!current_video_context || !current_video_context->image_buffer_write)
return false;
if (!current_video_context->image_buffer_write(video_context_data,
img->frame, img->width, img->height, img->pitch,
img->rgb32, img->index, img->handle))
return false;
}
break;
case GFX_CTL_GET_VIDEO_OUTPUT_PREV:
if (!current_video_context
|| !current_video_context->get_video_output_prev)
return false;
current_video_context->get_video_output_prev(video_context_data);
break;
case GFX_CTL_GET_VIDEO_OUTPUT_NEXT:
if (!current_video_context ||
!current_video_context->get_video_output_next)
return false;
current_video_context->get_video_output_next(video_context_data);
break;
case GFX_CTL_BIND_HW_RENDER:
{
bool *enable = (bool*)data;
if (!current_video_context || !current_video_context->bind_hw_render)
return false;
current_video_context->bind_hw_render(video_context_data, *enable);
}
break;
case GFX_CTL_SET:
if (!data)
return false;
current_video_context = (const gfx_ctx_driver_t*)data;
break;
case GFX_CTL_DESTROY:
current_video_context = NULL;
break;
case GFX_CTL_UPDATE_WINDOW_TITLE:
if (!current_video_context || !current_video_context->update_window_title)
return false;
current_video_context->update_window_title(video_context_data);
break;
case GFX_CTL_SWAP_BUFFERS:
if (!current_video_context || !current_video_context->swap_buffers)
return false;
current_video_context->swap_buffers(video_context_data);
break;
case GFX_CTL_FOCUS:
if (!video_context_data || !current_video_context->has_focus)
return false;
if (!current_video_context->has_focus(video_context_data))
return false;
break;
case GFX_CTL_HAS_WINDOWED:
if (!video_context_data)
return false;
if (!current_video_context->has_windowed(video_context_data))
return false;
break;
case GFX_CTL_FREE:
if (current_video_context->destroy)
current_video_context->destroy(video_context_data);
current_video_context = NULL;
video_context_data = NULL;
break;
case GFX_CTL_GET_VIDEO_OUTPUT_SIZE:
{
gfx_ctx_size_t *size_data = (gfx_ctx_size_t*)data;
if (!size_data)
return false;
if (!current_video_context || !current_video_context->get_video_output_size)
return false;
current_video_context->get_video_output_size(video_context_data,
size_data->width, size_data->height);
}
break;
case GFX_CTL_SWAP_INTERVAL:
{
unsigned *interval = (unsigned*)data;
if (!current_video_context || !current_video_context->swap_interval)
return false;
current_video_context->swap_interval(video_context_data, *interval);
}
break;
case GFX_CTL_PROC_ADDRESS_GET:
{
gfx_ctx_proc_address_t *proc = (gfx_ctx_proc_address_t*)data;
if (!current_video_context || !current_video_context->get_proc_address)
return false;
bool video_context_driver_write_to_image_buffer(gfx_ctx_image_t *img)
{
if (!current_video_context || !current_video_context->image_buffer_write)
return false;
if (!current_video_context->image_buffer_write(video_context_data,
img->frame, img->width, img->height, img->pitch,
img->rgb32, img->index, img->handle))
return false;
return true;
}
proc->addr = current_video_context->get_proc_address(proc->sym);
}
break;
case GFX_CTL_GET_METRICS:
{
gfx_ctx_metrics_t *metrics = (gfx_ctx_metrics_t*)data;
if (!current_video_context || !current_video_context->get_metrics)
return false;
if (!current_video_context->get_metrics(video_context_data,
metrics->type,
metrics->value))
return false;
}
break;
case GFX_CTL_INPUT_DRIVER:
{
gfx_ctx_input_t *inp = (gfx_ctx_input_t*)data;
if (!current_video_context || !current_video_context->input_driver)
return false;
current_video_context->input_driver(
video_context_data, inp->input, inp->input_data);
}
break;
case GFX_CTL_SUPPRESS_SCREENSAVER:
{
bool *bool_data = (bool*)data;
if (!video_context_data || !current_video_context)
return false;
if (!current_video_context->suppress_screensaver(
video_context_data, *bool_data))
return false;
}
break;
case GFX_CTL_IDENT_GET:
{
gfx_ctx_ident_t *ident = (gfx_ctx_ident_t*)data;
ident->ident = NULL;
if (current_video_context)
ident->ident = current_video_context->ident;
}
break;
case GFX_CTL_SET_VIDEO_MODE:
{
gfx_ctx_mode_t *mode_info = (gfx_ctx_mode_t*)data;
if (!current_video_context || !current_video_context->set_video_mode)
return false;
if (!current_video_context->set_video_mode(
video_context_data, mode_info->width,
mode_info->height, mode_info->fullscreen))
return false;
}
break;
case GFX_CTL_SET_RESIZE:
{
gfx_ctx_mode_t *mode_info = (gfx_ctx_mode_t*)data;
if (!current_video_context)
return false;
if (!current_video_context->set_resize(
video_context_data, mode_info->width, mode_info->height))
return false;
}
break;
case GFX_CTL_GET_VIDEO_SIZE:
{
gfx_ctx_mode_t *mode_info = (gfx_ctx_mode_t*)data;
if (!current_video_context || !current_video_context->get_video_size)
return false;
current_video_context->get_video_size(video_context_data, &mode_info->width, &mode_info->height);
}
break;
case GFX_CTL_GET_CONTEXT_DATA:
{
if (!current_video_context || !current_video_context->get_context_data)
return false;
*(void**)data = current_video_context->get_context_data(video_context_data);
}
break;
case GFX_CTL_SHOW_MOUSE:
{
bool *bool_data = (bool*)data;
if (!current_video_context || !current_video_context->show_mouse)
return false;
current_video_context->show_mouse(video_context_data, *bool_data);
}
break;
case GFX_CTL_SET_VIDEO_CONTEXT_DATA:
video_context_data = data;
break;
case GFX_CTL_GET_FLAGS:
{
gfx_ctx_flags_t *flags = (gfx_ctx_flags_t*)data;
if (!flags)
return false;
if (!current_video_context || !current_video_context->get_flags)
return false;
flags->flags = current_video_context->get_flags(video_context_data);
}
break;
case GFX_CTL_SET_FLAGS:
{
gfx_ctx_flags_t *flags = (gfx_ctx_flags_t*)data;
if (!flags)
return false;
if (!current_video_context || !current_video_context->set_flags)
return false;
current_video_context->set_flags(video_context_data, flags->flags);
}
break;
case GFX_CTL_NONE:
default:
break;
}
bool video_context_driver_get_video_output_prev(void)
{
if (!current_video_context
|| !current_video_context->get_video_output_prev)
return false;
current_video_context->get_video_output_prev(video_context_data);
return true;
}
bool video_context_driver_get_video_output_next(void)
{
if (!current_video_context ||
!current_video_context->get_video_output_next)
return false;
current_video_context->get_video_output_next(video_context_data);
return true;
}
bool video_context_driver_bind_hw_render(bool *enable)
{
if (!current_video_context || !current_video_context->bind_hw_render)
return false;
current_video_context->bind_hw_render(video_context_data, *enable);
return true;
}
bool video_context_driver_set(const gfx_ctx_driver_t *data)
{
if (!data)
return false;
current_video_context = data;
return true;
}
void video_context_driver_destroy(void)
{
current_video_context = NULL;
}
bool video_context_driver_update_window_title(void)
{
if (!current_video_context || !current_video_context->update_window_title)
return false;
current_video_context->update_window_title(video_context_data);
return true;
}
bool video_context_driver_swap_buffers(void)
{
if (!current_video_context || !current_video_context->swap_buffers)
return false;
current_video_context->swap_buffers(video_context_data);
return true;
}
bool video_context_driver_focus(void)
{
if (!video_context_data || !current_video_context->has_focus)
return false;
if (!current_video_context->has_focus(video_context_data))
return false;
return true;
}
bool video_context_driver_translate_aspect(gfx_ctx_aspect_t *aspect)
{
if (!video_context_data || !aspect)
return false;
if (!current_video_context->translate_aspect)
return false;
*aspect->aspect = current_video_context->translate_aspect(
video_context_data, aspect->width, aspect->height);
return true;
}
bool video_context_driver_has_windowed(void)
{
if (!video_context_data)
return false;
if (!current_video_context->has_windowed(video_context_data))
return false;
return true;
}
void video_context_driver_free(void)
{
if (current_video_context->destroy)
current_video_context->destroy(video_context_data);
current_video_context = NULL;
video_context_data = NULL;
}
bool video_context_driver_get_video_output_size(gfx_ctx_size_t *size_data)
{
if (!size_data)
return false;
if (!current_video_context || !current_video_context->get_video_output_size)
return false;
current_video_context->get_video_output_size(video_context_data,
size_data->width, size_data->height);
return true;
}
bool video_context_driver_swap_interval(unsigned *interval)
{
if (!current_video_context || !current_video_context->swap_interval)
return false;
current_video_context->swap_interval(video_context_data, *interval);
return true;
}
bool video_context_driver_get_proc_address(gfx_ctx_proc_address_t *proc)
{
if (!current_video_context || !current_video_context->get_proc_address)
return false;
proc->addr = current_video_context->get_proc_address(proc->sym);
return true;
}
bool video_context_driver_get_metrics(gfx_ctx_metrics_t *metrics)
{
if (!current_video_context || !current_video_context->get_metrics)
return false;
if (!current_video_context->get_metrics(video_context_data,
metrics->type,
metrics->value))
return false;
return true;
}
bool video_context_driver_input_driver(gfx_ctx_input_t *inp)
{
if (!current_video_context || !current_video_context->input_driver)
return false;
current_video_context->input_driver(
video_context_data, inp->input, inp->input_data);
return true;
}
bool video_context_driver_suppress_screensaver(bool *bool_data)
{
if (!video_context_data || !current_video_context)
return false;
if (!current_video_context->suppress_screensaver(
video_context_data, *bool_data))
return false;
return true;
}
bool video_context_driver_get_ident(gfx_ctx_ident_t *ident)
{
if (!ident)
return false;
ident->ident = NULL;
if (current_video_context)
ident->ident = current_video_context->ident;
return true;
}
bool video_context_driver_set_video_mode(gfx_ctx_mode_t *mode_info)
{
if (!current_video_context || !current_video_context->set_video_mode)
return false;
if (!current_video_context->set_video_mode(
video_context_data, mode_info->width,
mode_info->height, mode_info->fullscreen))
return false;
return true;
}
bool video_context_driver_set_resize(gfx_ctx_mode_t *mode_info)
{
if (!current_video_context)
return false;
if (!current_video_context->set_resize(
video_context_data, mode_info->width, mode_info->height))
return false;
return true;
}
bool video_context_driver_get_video_size(gfx_ctx_mode_t *mode_info)
{
if (!current_video_context || !current_video_context->get_video_size)
return false;
current_video_context->get_video_size(video_context_data,
&mode_info->width, &mode_info->height);
return true;
}
bool video_context_driver_get_context_data(void *data)
{
if (!current_video_context || !current_video_context->get_context_data)
return false;
*(void**)data = current_video_context->get_context_data(video_context_data);
return true;
}
bool video_context_driver_show_mouse(bool *bool_data)
{
if (!current_video_context || !current_video_context->show_mouse)
return false;
current_video_context->show_mouse(video_context_data, *bool_data);
return true;
}
void video_context_driver_set_data(void *data)
{
video_context_data = data;
}
bool video_context_driver_get_flags(gfx_ctx_flags_t *flags)
{
if (!flags)
return false;
if (!current_video_context || !current_video_context->get_flags)
return false;
flags->flags = current_video_context->get_flags(video_context_data);
return true;
}
bool video_context_driver_set_flags(gfx_ctx_flags_t *flags)
{
if (!flags)
return false;
if (!current_video_context || !current_video_context->set_flags)
return false;
current_video_context->set_flags(video_context_data, flags->flags);
return true;
}

104
gfx/video_context_driver.h
View File

@ -58,44 +58,6 @@ enum display_flags
GFX_CTX_FLAGS_GL_CORE_CONTEXT
};
enum gfx_ctx_ctl_state
{
GFX_CTL_NONE = 0,
GFX_CTL_CHECK_WINDOW,
GFX_CTL_FOCUS,
GFX_CTL_DESTROY,
GFX_CTL_FREE,
GFX_CTL_SWAP_BUFFERS,
GFX_CTL_HAS_WINDOWED,
GFX_CTL_UPDATE_WINDOW_TITLE,
GFX_CTL_SHOW_MOUSE,
GFX_CTL_SET,
GFX_CTL_BIND_HW_RENDER,
GFX_CTL_GET_VIDEO_OUTPUT_PREV,
GFX_CTL_GET_VIDEO_OUTPUT_NEXT,
GFX_CTL_IMAGE_BUFFER_INIT,
GFX_CTL_IMAGE_BUFFER_WRITE,
/* Finds next driver in graphics context driver array. */
GFX_CTL_FIND_NEXT_DRIVER,
/* Finds previous driver in graphics context driver array. */
GFX_CTL_FIND_PREV_DRIVER,
GFX_CTL_GET_VIDEO_OUTPUT_SIZE,
GFX_CTL_SWAP_INTERVAL,
GFX_CTL_PROC_ADDRESS_GET,
GFX_CTL_TRANSLATE_ASPECT,
GFX_CTL_GET_FLAGS,
GFX_CTL_SET_FLAGS,
GFX_CTL_GET_METRICS,
GFX_CTL_INPUT_DRIVER,
GFX_CTL_SUPPRESS_SCREENSAVER,
GFX_CTL_IDENT_GET,
GFX_CTL_SET_VIDEO_MODE,
GFX_CTL_SET_RESIZE,
GFX_CTL_GET_VIDEO_SIZE,
GFX_CTL_SET_VIDEO_CONTEXT_DATA,
GFX_CTL_GET_CONTEXT_DATA
};
typedef void (*gfx_ctx_proc_t)(void);
typedef struct gfx_ctx_driver
@ -284,7 +246,7 @@ extern const gfx_ctx_driver_t gfx_ctx_opendingux_fbdev;
extern const gfx_ctx_driver_t gfx_ctx_null;
/**
* video_driver_context_init_first:
* video_context_driver_init_first:
* @data : Input data.
* @ident : Identifier of graphics context driver to find.
* @api : API of higher-level graphics API.
@ -297,10 +259,70 @@ extern const gfx_ctx_driver_t gfx_ctx_null;
*
* Returns: graphics context driver if found, otherwise NULL.
**/
const gfx_ctx_driver_t *video_driver_context_init_first(void *data, const char *ident,
const gfx_ctx_driver_t *video_context_driver_init_first(void *data, const char *ident,
enum gfx_ctx_api api, unsigned major, unsigned minor, bool hw_render_ctx);
bool gfx_ctx_ctl(enum gfx_ctx_ctl_state state, void *data);
bool video_context_driver_check_window(gfx_ctx_size_t *size_data);
bool video_context_driver_find_prev_driver(void);
bool video_context_driver_find_next_driver(void);
bool video_context_driver_init_image_buffer(const video_info_t *data);
bool video_context_driver_write_to_image_buffer(gfx_ctx_image_t *img);
bool video_context_driver_get_video_output_prev(void);
bool video_context_driver_get_video_output_next(void);
bool video_context_driver_bind_hw_render(bool *enable);
bool video_context_driver_set(const gfx_ctx_driver_t *data);
void video_context_driver_destroy(void);
bool video_context_driver_update_window_title(void);
bool video_context_driver_swap_buffers(void);
bool video_context_driver_focus(void);
bool video_context_driver_get_video_output_size(gfx_ctx_size_t *size_data);
bool video_context_driver_swap_interval(unsigned *interval);
bool video_context_driver_get_proc_address(gfx_ctx_proc_address_t *proc);
bool video_context_driver_suppress_screensaver(bool *bool_data);
bool video_context_driver_get_ident(gfx_ctx_ident_t *ident);
bool video_context_driver_set_video_mode(gfx_ctx_mode_t *mode_info);
bool video_context_driver_set_resize(gfx_ctx_mode_t *mode_info);
bool video_context_driver_get_video_size(gfx_ctx_mode_t *mode_info);
bool video_context_driver_get_context_data(void *data);
bool video_context_driver_show_mouse(bool *bool_data);
void video_context_driver_set_data(void *data);
bool video_context_driver_get_flags(gfx_ctx_flags_t *flags);
bool video_context_driver_set_flags(gfx_ctx_flags_t *flags);
bool video_context_driver_get_metrics(gfx_ctx_metrics_t *metrics);
bool video_context_driver_translate_aspect(gfx_ctx_aspect_t *aspect);
bool video_context_driver_input_driver(gfx_ctx_input_t *inp);
bool video_context_driver_has_windowed(void);
void video_context_driver_free(void);
#ifdef __cplusplus
}

6
gfx/video_driver.c
View File

@ -792,7 +792,7 @@ bool video_driver_set_video_mode(unsigned width,
mode.height = height;
mode.fullscreen = fullscreen;
return gfx_ctx_ctl(GFX_CTL_SET_VIDEO_MODE, &mode);
return video_context_driver_set_video_mode(&mode);
}
bool video_driver_get_video_output_size(unsigned *width, unsigned *height)
@ -1496,7 +1496,7 @@ bool video_driver_get_next_video_out(void)
return false;
if (!video_driver_poke->get_video_output_next)
return gfx_ctx_ctl(GFX_CTL_GET_VIDEO_OUTPUT_NEXT, NULL);
return video_context_driver_get_video_output_next();
video_driver_poke->get_video_output_next(video_driver_data);
return true;
}
@ -1507,7 +1507,7 @@ bool video_driver_get_prev_video_out(void)
return false;
if (!video_driver_poke->get_video_output_prev)
return gfx_ctx_ctl(GFX_CTL_GET_VIDEO_OUTPUT_NEXT, NULL);
return video_context_driver_get_video_output_prev();
video_driver_poke->get_video_output_prev(video_driver_data);
return true;
}

2
gfx/video_shader_driver.c
View File

@ -43,7 +43,7 @@ static const shader_backend_t *video_shader_set_backend(enum rarch_shader_type t
#ifdef HAVE_CG
gfx_ctx_flags_t flags;
gfx_ctx_ctl(GFX_CTL_GET_FLAGS, &flags);
video_context_driver_get_flags(&flags);
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT))
{

2
menu/menu_display.c
View File

@ -411,7 +411,7 @@ float menu_display_get_dpi(void)
if (settings->menu.dpi.override_enable)
return settings->menu.dpi.override_value;
else if (!gfx_ctx_ctl(GFX_CTL_GET_METRICS, &metrics) || !dpi)
else if (!video_context_driver_get_metrics(&metrics) || !dpi)
return menu_dpi_override_value;
return dpi;

8
menu/menu_displaylist.c
View File

@ -776,7 +776,7 @@ static int menu_displaylist_parse_system_info(menu_displaylist_info_t *info)
}
#if defined(HAVE_OPENGL) || defined(HAVE_GLES)
gfx_ctx_ctl(GFX_CTL_IDENT_GET, &ident_info);
video_context_driver_get_ident(&ident_info);
tmp_string = ident_info.ident;
strlcpy(tmp,
@ -797,7 +797,7 @@ static int menu_displaylist_parse_system_info(menu_displaylist_info_t *info)
metrics.type = DISPLAY_METRIC_MM_WIDTH;
metrics.value = &val;
if (gfx_ctx_ctl(GFX_CTL_GET_METRICS, &metrics))
if (video_context_driver_get_metrics(&metrics))
{
snprintf(tmp, sizeof(tmp), "%s: %.2f",
menu_hash_to_str(
@ -809,7 +809,7 @@ static int menu_displaylist_parse_system_info(menu_displaylist_info_t *info)
metrics.type = DISPLAY_METRIC_MM_HEIGHT;
if (gfx_ctx_ctl(GFX_CTL_GET_METRICS, &metrics))
if (video_context_driver_get_metrics(&metrics))
{
snprintf(tmp, sizeof(tmp), "%s: %.2f",
menu_hash_to_str(
@ -821,7 +821,7 @@ static int menu_displaylist_parse_system_info(menu_displaylist_info_t *info)
metrics.type = DISPLAY_METRIC_DPI;
if (gfx_ctx_ctl(GFX_CTL_GET_METRICS, &metrics))
if (video_context_driver_get_metrics(&metrics))
{
snprintf(tmp, sizeof(tmp), "%s: %.2f",
menu_hash_to_str(

2
menu/menu_input.c
View File

@ -1108,7 +1108,7 @@ static int menu_input_pointer_post_iterate(
metrics.type = DISPLAY_METRIC_DPI;
metrics.value = &dpi;
gfx_ctx_ctl(GFX_CTL_GET_METRICS, &metrics);
video_context_driver_get_metrics(&metrics);
if (!pointer_oldpressed[0])
{