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

Go through driver_get_ptr to grab pointer to driver struct

Browse Source
This commit is contained in:
twinaphex 2015-03-18 19:40:00 +01:00
parent 7378299282
commit 3670ef2ac5
71 changed files with 1272 additions and 886 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
audio/audio_driver.c
View File

@ -213,9 +213,11 @@ const char* config_get_audio_driver_options(void)
void find_audio_driver(void)
{
driver_t *driver = driver_get_ptr();
int i = find_driver_index("audio_driver", g_settings.audio.driver);
if (i >= 0)
driver.audio = (const audio_driver_t*)audio_driver_find_handle(i);
driver->audio = (const audio_driver_t*)audio_driver_find_handle(i);
else
{
unsigned d;
@ -226,17 +228,19 @@ void find_audio_driver(void)
RARCH_LOG_OUTPUT("\t%s\n", audio_driver_find_ident(d));
RARCH_WARN("Going to default to first audio driver...\n");
driver.audio = (const audio_driver_t*)audio_driver_find_handle(0);
driver->audio = (const audio_driver_t*)audio_driver_find_handle(0);
if (!driver.audio)
if (!driver->audio)
rarch_fail(1, "find_audio_driver()");
}
}
void uninit_audio(void)
{
if (driver.audio_data && driver.audio)
driver.audio->free(driver.audio_data);
driver_t *driver = driver_get_ptr();
if (driver->audio_data && driver->audio)
driver->audio->free(driver->audio_data);
free(g_extern.audio_data.conv_outsamples);
g_extern.audio_data.conv_outsamples = NULL;
@ -247,12 +251,12 @@ void uninit_audio(void)
if (!g_settings.audio.enable)
{
driver.audio_active = false;
driver->audio_active = false;
return;
}
rarch_resampler_freep(&driver.resampler,
&driver.resampler_data);
rarch_resampler_freep(&driver->resampler,
&driver->resampler_data);
free(g_extern.audio_data.data);
g_extern.audio_data.data = NULL;
@ -269,11 +273,12 @@ void init_audio(void)
{
size_t outsamples_max, max_bufsamples = AUDIO_CHUNK_SIZE_NONBLOCKING * 2;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
audio_convert_init_simd();
/* Resource leaks will follow if audio is initialized twice. */
if (driver.audio_data)
if (driver->audio_data)
return;
/* Accomodate rewind since at some point we might have two full buffers. */
@ -297,7 +302,7 @@ void init_audio(void)
if (!g_settings.audio.enable)
{
driver.audio_active = false;
driver->audio_active = false;
return;
}
@ -306,10 +311,10 @@ void init_audio(void)
if (g_extern.system.audio_callback.callback)
{
RARCH_LOG("Starting threaded audio driver ...\n");
if (!rarch_threaded_audio_init(&driver.audio, &driver.audio_data,
if (!rarch_threaded_audio_init(&driver->audio, &driver->audio_data,
*g_settings.audio.device ? g_settings.audio.device : NULL,
g_settings.audio.out_rate, g_settings.audio.latency,
driver.audio))
driver->audio))
{
RARCH_ERR("Cannot open threaded audio driver ... Exiting ...\n");
rarch_fail(1, "init_audio()");
@ -318,22 +323,22 @@ void init_audio(void)
else
#endif
{
driver.audio_data = driver.audio->init(*g_settings.audio.device ?
driver->audio_data = driver->audio->init(*g_settings.audio.device ?
g_settings.audio.device : NULL,
g_settings.audio.out_rate, g_settings.audio.latency);
}
if (!driver.audio_data)
if (!driver->audio_data)
{
RARCH_ERR("Failed to initialize audio driver. Will continue without audio.\n");
driver.audio_active = false;
driver->audio_active = false;
}
g_extern.audio_data.use_float = false;
if (driver.audio_active && driver.audio->use_float(driver.audio_data))
if (driver->audio_active && driver->audio->use_float(driver->audio_data))
g_extern.audio_data.use_float = true;
if (!g_settings.audio.sync && driver.audio_active)
if (!g_settings.audio.sync && driver->audio_active)
{
rarch_main_command(RARCH_CMD_AUDIO_SET_NONBLOCKING_STATE);
g_extern.audio_data.chunk_size =
@ -352,13 +357,13 @@ void init_audio(void)
g_extern.audio_data.src_ratio =
(double)g_settings.audio.out_rate / g_extern.audio_data.in_rate;
if (!rarch_resampler_realloc(&driver.resampler_data,
&driver.resampler,
if (!rarch_resampler_realloc(&driver->resampler_data,
&driver->resampler,
g_settings.audio.resampler, g_extern.audio_data.orig_src_ratio))
{
RARCH_ERR("Failed to initialize resampler \"%s\".\n",
g_settings.audio.resampler);
driver.audio_active = false;
driver->audio_active = false;
}
rarch_assert(g_extern.audio_data.data = (float*)
@ -372,13 +377,13 @@ void init_audio(void)
malloc(outsamples_max * sizeof(float)));
g_extern.audio_data.rate_control = false;
if (!g_extern.system.audio_callback.callback && driver.audio_active &&
if (!g_extern.system.audio_callback.callback && driver->audio_active &&
g_settings.audio.rate_control)
{
if (driver.audio->buffer_size && driver.audio->write_avail)
if (driver->audio->buffer_size && driver->audio->write_avail)
{
g_extern.audio_data.driver_buffer_size =
driver.audio->buffer_size(driver.audio_data);
driver->audio->buffer_size(driver->audio_data);
g_extern.audio_data.rate_control = true;
}
else
@ -389,17 +394,18 @@ void init_audio(void)
runloop->measure_data.buffer_free_samples_count = 0;
if (driver.audio_active && !g_settings.audio.mute_enable &&
if (driver->audio_active && !g_settings.audio.mute_enable &&
g_extern.system.audio_callback.callback)
{
/* Threaded driver is initially stopped. */
driver.audio->start(driver.audio_data);
driver->audio->start(driver->audio_data);
}
}
bool audio_driver_mute_toggle(void)
{
if (!driver.audio_data || !driver.audio_active)
driver_t *driver = driver_get_ptr();
if (!driver->audio_data || !driver->audio_active)
return false;
g_settings.audio.mute_enable = !g_settings.audio.mute_enable;
@ -408,7 +414,7 @@ bool audio_driver_mute_toggle(void)
rarch_main_command(RARCH_CMD_AUDIO_STOP);
else if (!rarch_main_command(RARCH_CMD_AUDIO_START))
{
driver.audio_active = false;
driver->audio_active = false;
return false;
}
@ -425,8 +431,11 @@ void audio_driver_readjust_input_rate(void)
double direction, adjust;
int half_size, delta_mid;
unsigned write_idx;
int avail = driver.audio->write_avail(driver.audio_data);
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
int avail = 0;
avail = driver->audio->write_avail(driver->audio_data);
#if 0
RARCH_LOG_OUTPUT("Audio buffer is %u%% full\n",

47
camera/camera_driver.c
View File

@ -116,9 +116,11 @@ const char* config_get_camera_driver_options(void)
void find_camera_driver(void)
{
driver_t *driver = driver_get_ptr();
int i = find_driver_index("camera_driver", g_settings.camera.driver);
if (i >= 0)
driver.camera = (const camera_driver_t*)camera_driver_find_handle(i);
driver->camera = (const camera_driver_t*)camera_driver_find_handle(i);
else
{
unsigned d;
@ -130,9 +132,9 @@ void find_camera_driver(void)
RARCH_WARN("Going to default to first camera driver...\n");
driver.camera = (const camera_driver_t*)camera_driver_find_handle(0);
driver->camera = (const camera_driver_t*)camera_driver_find_handle(0);
if (!driver.camera)
if (!driver->camera)
rarch_fail(1, "find_camera_driver()");
}
}
@ -147,10 +149,11 @@ void find_camera_driver(void)
**/
bool driver_camera_start(void)
{
if (driver.camera && driver.camera_data && driver.camera->start)
driver_t *driver = driver_get_ptr();
if (driver->camera && driver->camera_data && driver->camera->start)
{
if (g_settings.camera.allow)
return driver.camera->start(driver.camera_data);
return driver->camera->start(driver->camera_data);
rarch_main_msg_queue_push(
"Camera is explicitly disabled.\n", 1, 180, false);
@ -168,8 +171,9 @@ bool driver_camera_start(void)
**/
void driver_camera_stop(void)
{
if (driver.camera && driver.camera->stop && driver.camera_data)
driver.camera->stop(driver.camera_data);
driver_t *driver = driver_get_ptr();
if (driver->camera && driver->camera->stop && driver->camera_data)
driver->camera->stop(driver->camera_data);
}
/**
@ -182,21 +186,26 @@ void driver_camera_stop(void)
**/
void driver_camera_poll(void)
{
if (driver.camera && driver.camera->poll && driver.camera_data)
driver.camera->poll(driver.camera_data,
driver_t *driver = driver_get_ptr();
if (driver->camera && driver->camera->poll && driver->camera_data)
driver->camera->poll(driver->camera_data,
g_extern.system.camera_callback.frame_raw_framebuffer,
g_extern.system.camera_callback.frame_opengl_texture);
}
void init_camera(void)
{
/* Resource leaks will follow if camera is initialized twice. */
if (driver.camera_data)
driver_t *driver = driver_get_ptr();
if (driver->camera_data)
{
/* Resource leaks will follow if camera is initialized twice. */
return;
}
find_camera_driver();
driver.camera_data = driver.camera->init(
driver->camera_data = driver->camera->init(
*g_settings.camera.device ? g_settings.camera.device : NULL,
g_extern.system.camera_callback.caps,
g_settings.camera.width ?
@ -204,10 +213,10 @@ void init_camera(void)
g_settings.camera.height ?
g_settings.camera.height : g_extern.system.camera_callback.height);
if (!driver.camera_data)
if (!driver->camera_data)
{
RARCH_ERR("Failed to initialize camera driver. Will continue without camera.\n");
driver.camera_active = false;
driver->camera_active = false;
}
if (g_extern.system.camera_callback.initialized)
@ -216,13 +225,15 @@ void init_camera(void)
void uninit_camera(void)
{
if (driver.camera_data && driver.camera)
driver_t *driver = driver_get_ptr();
if (driver->camera_data && driver->camera)
{
if (g_extern.system.camera_callback.deinitialized)
g_extern.system.camera_callback.deinitialized();
if (driver.camera->free)
driver.camera->free(driver.camera_data);
if (driver->camera->free)
driver->camera->free(driver->camera_data);
}
driver.camera_data = NULL;
driver->camera_data = NULL;
}

5
command.c
View File

@ -217,8 +217,9 @@ static bool cmd_set_shader(const char *arg)
char msg[PATH_MAX_LENGTH];
const char *ext;
enum rarch_shader_type type = RARCH_SHADER_NONE;
driver_t *driver = driver_get_ptr();
if (!driver.video->set_shader)
if (!driver->video->set_shader)
return false;
ext = path_get_extension(arg);
@ -235,7 +236,7 @@ static bool cmd_set_shader(const char *arg)
rarch_main_msg_queue_push(msg, 1, 120, true);
RARCH_LOG("Applying shader \"%s\".\n", arg);
return driver.video->set_shader(driver.video_data, type, arg);
return driver->video->set_shader(driver->video_data, type, arg);
}
static const struct cmd_action_map action_map[] = {

5
driver.c
View File

@ -423,3 +423,8 @@ void uninit_drivers(int flags)
if ((flags & DRIVER_AUDIO) && !driver.audio_data_own)
driver.audio_data = NULL;
}
driver_t *driver_get_ptr(void)
{
return &driver;
}

2
driver.h
View File

@ -393,7 +393,7 @@ bool driver_update_system_av_info(const struct retro_system_av_info *info);
**/
int find_driver_index(const char * label, const char *drv);
extern driver_t driver;
driver_t *driver_get_ptr(void);
#ifdef __cplusplus
}

29
dynamic.c
View File

@ -465,6 +465,8 @@ void init_libretro_sym(bool dummy)
**/
void uninit_libretro_sym(void)
{
driver_t *driver = driver_get_ptr();
#ifdef HAVE_DYNAMIC
if (lib_handle)
dylib_close(lib_handle);
@ -481,8 +483,8 @@ void uninit_libretro_sym(void)
free(g_extern.system.special);
free(g_extern.system.ports);
memset(&g_extern.system, 0, sizeof(g_extern.system));
driver.camera_active = false;
driver.location_active = false;
driver->camera_active = false;
driver->location_active = false;
/* Performance counters no longer valid. */
retro_perf_clear();
@ -609,6 +611,7 @@ static void rarch_log_libretro(enum retro_log_level level,
bool rarch_environment_cb(unsigned cmd, void *data)
{
unsigned p;
driver_t *driver = driver_get_ptr();
if (ignore_environment_cb)
return false;
@ -688,10 +691,10 @@ bool rarch_environment_cb(unsigned cmd, void *data)
g_extern.system.rotation = rotation;
if (driver.video && driver.video->set_rotation)
if (driver->video && driver->video->set_rotation)
{
if (driver.video_data)
driver.video->set_rotation(driver.video_data, rotation);
if (driver->video_data)
driver->video->set_rotation(driver->video_data, rotation);
}
else
return false;
@ -970,7 +973,7 @@ bool rarch_environment_cb(unsigned cmd, void *data)
const struct retro_audio_callback *info =
(const struct retro_audio_callback*)data;
if (driver.recording_data) // A/V sync is a must.
if (driver->recording_data) // A/V sync is a must.
return false;
#ifdef HAVE_NETPLAY
@ -1016,9 +1019,9 @@ bool rarch_environment_cb(unsigned cmd, void *data)
uint64_t *mask = (uint64_t*)data;
RARCH_LOG("Environ GET_INPUT_DEVICE_CAPABILITIES.\n");
if (driver.input &&
driver.input->get_capabilities && driver.input_data)
*mask = driver.input->get_capabilities(driver.input_data);
if (driver->input &&
driver->input->get_capabilities && driver->input_data)
*mask = driver->input->get_capabilities(driver->input_data);
else
return false;
break;
@ -1044,7 +1047,7 @@ bool rarch_environment_cb(unsigned cmd, void *data)
cb->start = driver_camera_start;
cb->stop = driver_camera_stop;
g_extern.system.camera_callback = *cb;
driver.camera_active = cb->caps != 0;
driver->camera_active = cb->caps != 0;
break;
}
@ -1059,7 +1062,7 @@ bool rarch_environment_cb(unsigned cmd, void *data)
cb->get_position = driver_location_get_position;
cb->set_interval = driver_location_set_interval;
g_extern.system.location_callback = *cb;
driver.location_active = true;
driver->location_active = true;
break;
}
@ -1218,8 +1221,8 @@ bool rarch_environment_cb(unsigned cmd, void *data)
*g_extern.fullpath = '\0';
#if defined(RARCH_CONSOLE)
if (driver.frontend_ctx && driver.frontend_ctx->set_fork)
driver.frontend_ctx->set_fork(true, true);
if (driver->frontend_ctx && driver->frontend_ctx->set_fork)
driver->frontend_ctx->set_fork(true, true);
#elif defined(HAVE_DYNAMIC)
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
#endif

31
frontend/frontend.c
View File

@ -85,6 +85,8 @@ void main_exit_save_config(void)
**/
void main_exit(args_type() args)
{
driver_t *driver = driver_get_ptr();
g_extern.system.shutdown = false;
main_exit_save_config();
@ -93,7 +95,7 @@ void main_exit(args_type() args)
{
#ifdef HAVE_MENU
/* Do not want menu context to live any more. */
driver.menu_data_own = false;
driver->menu_data_own = false;
#endif
rarch_main_deinit();
}
@ -104,17 +106,17 @@ void main_exit(args_type() args)
logger_shutdown();
#endif
if (driver.frontend_ctx && driver.frontend_ctx->deinit)
driver.frontend_ctx->deinit(args);
if (driver->frontend_ctx && driver->frontend_ctx->deinit)
driver->frontend_ctx->deinit(args);
if (driver.frontend_ctx && driver.frontend_ctx->exitspawn)
driver.frontend_ctx->exitspawn(g_settings.libretro,
if (driver->frontend_ctx && driver->frontend_ctx->exitspawn)
driver->frontend_ctx->exitspawn(g_settings.libretro,
sizeof(g_settings.libretro));
rarch_main_state_free();
if (driver.frontend_ctx && driver.frontend_ctx->shutdown)
driver.frontend_ctx->shutdown(false);
if (driver->frontend_ctx && driver->frontend_ctx->shutdown)
driver->frontend_ctx->shutdown(false);
}
static void check_defaults_dirs(void)
@ -273,22 +275,23 @@ returntype main_entry(signature())
declare_argv();
args_type() args = (args_type())args_initial_ptr();
int ret = 0;
driver_t *driver = driver_get_ptr();
driver.frontend_ctx = (frontend_ctx_driver_t*)frontend_ctx_init_first();
driver->frontend_ctx = (frontend_ctx_driver_t*)frontend_ctx_init_first();
if (!driver.frontend_ctx)
if (!driver->frontend_ctx)
RARCH_WARN("Frontend context could not be initialized.\n");
if (driver.frontend_ctx && driver.frontend_ctx->init)
driver.frontend_ctx->init(args);
if (driver->frontend_ctx && driver->frontend_ctx->init)
driver->frontend_ctx->init(args);
rarch_main_state_new();
if (driver.frontend_ctx)
if (driver->frontend_ctx)
{
if (!(ret = (main_load_content(argc, argv, args,
driver.frontend_ctx->environment_get,
driver.frontend_ctx->process_args))))
driver->frontend_ctx->environment_get,
driver->frontend_ctx->process_args))))
{
return_var(ret);
}

34
gfx/d3d/d3d.cpp
View File

@ -508,6 +508,7 @@ static bool d3d_construct(d3d_video_t *d3d,
void **input_data)
{
unsigned full_x, full_y;
driver_t *driver = driver_get_ptr();
d3d->should_resize = false;
#ifndef _XBOX
@ -598,9 +599,9 @@ static bool d3d_construct(d3d_video_t *d3d,
win_width, win_height,
NULL, NULL, NULL, d3d);
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)d3d->hWnd;
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)d3d->hWnd;
#endif
if (d3d && d3d->ctx_driver && d3d->ctx_driver->show_mouse)
@ -691,12 +692,13 @@ static const gfx_ctx_driver_t *d3d_get_context(void *data)
TODO: GL core contexts through ANGLE? */
enum gfx_ctx_api api = GFX_CTX_DIRECT3D9_API;
unsigned major = 9, minor = 0;
driver_t *driver = driver_get_ptr();
#if defined(_XBOX1)
api = GFX_CTX_DIRECT3D8_API;
major = 8;
#endif
return gfx_ctx_init_first(driver.video_data,
return gfx_ctx_init_first(driver->video_data,
g_settings.video.context_driver,
api, major, minor, false);
}
@ -705,11 +707,12 @@ static void *d3d_init(const video_info_t *info,
const input_driver_t **input, void **input_data)
{
d3d_video_t *vid = NULL;
driver_t *driver = driver_get_ptr();
#ifdef _XBOX
if (driver.video_data)
if (driver->video_data)
{
d3d_video_t *vid = (d3d_video_t*)driver.video_data;
d3d_video_t *vid = (d3d_video_t*)driver->video_data;
/* Reinitialize renderchain as we
* might have changed pixel formats.*/
@ -717,13 +720,13 @@ static void *d3d_init(const video_info_t *info,
if (input && input_data)
{
*input = driver.input;
*input_data = driver.input_data;
*input = driver->input;
*input_data = driver->input_data;
}
driver.video_data_own = true;
driver.input_data_own = true;
return driver.video_data;
driver->video_data_own = true;
driver->input_data_own = true;
return driver->video_data;
}
#endif
@ -763,8 +766,8 @@ static void *d3d_init(const video_info_t *info,
}
#ifdef _XBOX
driver.video_data_own = true;
driver.input_data_own = true;
driver->video_data_own = true;
driver->input_data_own = true;
#endif
return vid;
@ -1606,6 +1609,7 @@ static bool d3d_frame(void *data, const void *frame,
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
(void)i;
@ -1708,8 +1712,8 @@ static bool d3d_frame(void *data, const void *frame,
#ifdef HAVE_MENU
if (runloop->is_menu
&& driver.menu_ctx && driver.menu_ctx->frame)
driver.menu_ctx->frame();
&& driver->menu_ctx && driver->menu_ctx->frame)
driver->menu_ctx->frame();
#ifdef _XBOX
/* TODO - should be refactored. */

3
gfx/d3d/render_chain.cpp
View File

@ -587,6 +587,7 @@ void renderchain_blit_to_texture(void *data, const void *frame,
D3DLOCKED_RECT d3dlr;
renderchain_t *chain = (renderchain_t*)data;
Pass *first = (Pass*)&chain->passes[0];
driver_t *driver = driver_get_ptr();
if (first->last_width != width || first->last_height != height)
{
@ -594,7 +595,7 @@ void renderchain_blit_to_texture(void *data, const void *frame,
NULL, D3DLOCK_NOSYSLOCK);
}
d3d_texture_blit(driver.video_data, chain, first->tex,
d3d_texture_blit(driver->video_data, chain, first->tex,
&d3dlr, frame, width, height, pitch);
}

3
gfx/d3d/render_chain_xdk.h
View File

@ -256,6 +256,7 @@ static void renderchain_blit_to_texture(void *data, const void *frame,
{
D3DLOCKED_RECT d3dlr;
d3d_video_t *d3d = (d3d_video_t*)data;
driver_t *driver = driver_get_ptr();
if (d3d->last_width != width || d3d->last_height != height)
{
@ -263,6 +264,6 @@ static void renderchain_blit_to_texture(void *data, const void *frame,
0, &d3dlr, NULL, D3DLOCK_NOSYSLOCK);
}
d3d_texture_blit(driver.video_data, NULL, d3d->tex,
d3d_texture_blit(driver->video_data, NULL, d3d->tex,
&d3dlr, frame, width, height, pitch);
}

29
gfx/drivers/gl.c
View File

@ -1286,10 +1286,12 @@ static INLINE void gl_copy_frame(gl_t *gl, const void *frame,
else
#endif
{
driver_t *driver = driver_get_ptr();
glPixelStorei(GL_UNPACK_ALIGNMENT, video_pixel_get_alignment(width * gl->base_size));
/* Fallback for GLES devices without GL_BGRA_EXT. */
if (gl->base_size == 4 && driver.gfx_use_rgba)
if (gl->base_size == 4 && driver->gfx_use_rgba)
{
gl_convert_frame_argb8888_abgr8888(gl, gl->conv_buffer,
frame, width, height, pitch);
@ -1464,6 +1466,7 @@ static bool gl_frame(void *data, const void *frame,
{
gl_t *gl = (gl_t*)data;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
RARCH_PERFORMANCE_INIT(frame_run);
RARCH_PERFORMANCE_START(frame_run);
@ -1589,12 +1592,15 @@ static bool gl_frame(void *data, const void *frame,
gl_set_prev_texture(gl, &gl->tex_info);
#if defined(HAVE_MENU)
if (runloop->is_menu
&& driver.menu_ctx && driver.menu_ctx->frame)
driver.menu_ctx->frame();
{
driver_t *driver = driver_get_ptr();
if (runloop->is_menu
&& driver->menu_ctx && driver->menu_ctx->frame)
driver->menu_ctx->frame();
if (gl->menu_texture_enable)
gl_draw_texture(gl);
if (gl->menu_texture_enable)
gl_draw_texture(gl);
}
#endif
if (msg && gl->font_driver && gl->font_handle)
@ -1645,7 +1651,7 @@ static bool gl_frame(void *data, const void *frame,
/* Disable BFI during fast forward, slow-motion,
* and pause to prevent flicker. */
if (g_settings.video.black_frame_insertion &&
!driver.nonblock_state && !runloop->is_slowmotion
!driver->nonblock_state && !runloop->is_slowmotion
&& !runloop->is_paused)
{
gl->ctx_driver->swap_buffers(gl);
@ -1803,6 +1809,7 @@ static void gl_set_nonblock_state(void *data, bool state)
static bool resolve_extensions(gl_t *gl)
{
driver_t *driver = driver_get_ptr();
#ifndef HAVE_OPENGLES
const char *vendor = NULL;
const char *renderer = NULL;
@ -1842,7 +1849,7 @@ static bool resolve_extensions(gl_t *gl)
RARCH_LOG("[GL]: Using ARB_sync to reduce latency.\n");
#endif
driver.gfx_use_rgba = false;
driver->gfx_use_rgba = false;
#ifdef HAVE_OPENGLES2
const char *version = NULL;
bool gles3 = false;
@ -1853,7 +1860,7 @@ static bool resolve_extensions(gl_t *gl)
RARCH_LOG("[GL]: BGRA8888 extension found for GLES.\n");
else
{
driver.gfx_use_rgba = true;
driver->gfx_use_rgba = true;
RARCH_WARN("[GL]: GLES implementation does not have BGRA8888 extension.\n"
"32-bit path will require conversion.\n");
}
@ -1933,6 +1940,8 @@ static bool resolve_extensions(gl_t *gl)
static INLINE void gl_set_texture_fmts(gl_t *gl, bool rgb32)
{
driver_t *driver = driver_get_ptr();
gl->internal_fmt = RARCH_GL_INTERNAL_FORMAT16;
gl->texture_type = RARCH_GL_TEXTURE_TYPE16;
gl->texture_fmt = RARCH_GL_FORMAT16;
@ -1945,7 +1954,7 @@ static INLINE void gl_set_texture_fmts(gl_t *gl, bool rgb32)
gl->texture_fmt = RARCH_GL_FORMAT32;
gl->base_size = sizeof(uint32_t);
if (driver.gfx_use_rgba)
if (driver->gfx_use_rgba)
{
gl->internal_fmt = GL_RGBA;
gl->texture_type = GL_RGBA;

9
gfx/drivers/gx_gfx.c
View File

@ -431,7 +431,8 @@ static void gx_set_video_mode(void *data, unsigned fbWidth, unsigned lines,
static void gx_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
{
gx_video_t *gx = (gx_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
gx_video_t *gx = (gx_video_t*)driver->video_data;
if (aspect_ratio_idx == ASPECT_RATIO_SQUARE)
video_viewport_set_square_pixel(
@ -934,7 +935,8 @@ static void gx_resize(void *data)
static void gx_blit_line(unsigned x, unsigned y, const char *message)
{
gx_video_t *gx = (gx_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
gx_video_t *gx = (gx_video_t*)driver->video_data;
const GXColor b = {
.r = 0x00,
@ -1187,7 +1189,8 @@ static bool gx_has_windowed(void *data)
static void gx_free(void *data)
{
gx_video_t *gx = (gx_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
gx_video_t *gx = (gx_video_t*)driver->video_data;
#ifdef HAVE_OVERLAY
gx_free_overlay(gx);

25
gfx/drivers/sdl2_gfx.c
View File

@ -207,6 +207,8 @@ static void sdl2_render_msg(sdl2_video_t *vid, const char *msg)
static void sdl2_gfx_set_handles(sdl2_video_t *vid)
{
driver_t *driver = driver_get_ptr();
/* SysWMinfo headers are broken on OSX. */
#if defined(_WIN32) || defined(HAVE_X11)
SDL_SysWMinfo info;
@ -216,13 +218,13 @@ static void sdl2_gfx_set_handles(sdl2_video_t *vid)
return;
#if defined(_WIN32)
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)info.info.win.window;
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)info.info.win.window;
#elif defined(HAVE_X11)
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)info.info.x11.display;
driver.video_window = (uintptr_t)info.info.x11.window;
driver->display_type = RARCH_DISPLAY_X11;
driver->video_display = (uintptr_t)info.info.x11.display;
driver->video_window = (uintptr_t)info.info.x11.window;
#endif
#endif
}
@ -485,6 +487,7 @@ static bool sdl2_gfx_frame(void *data, const void *frame, unsigned width,
char buf[128];
sdl2_video_t *vid = (sdl2_video_t*)data;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (vid->should_resize)
sdl_refresh_viewport(vid);
@ -505,8 +508,8 @@ static bool sdl2_gfx_frame(void *data, const void *frame, unsigned width,
#ifdef HAVE_MENU
if (runloop->is_menu
&& driver.menu_ctx && driver.menu_ctx->frame)
driver.menu_ctx->frame();
&& driver->menu_ctx && driver->menu_ctx->frame)
driver->menu_ctx->frame();
#endif
if (vid->menu.active)
@ -547,13 +550,15 @@ static bool sdl2_gfx_focus(void *data)
static bool sdl2_gfx_suppress_screensaver(void *data, bool enable)
{
driver_t *driver = driver_get_ptr();
(void)data;
(void)enable;
if (driver.display_type == RARCH_DISPLAY_X11)
if (driver->display_type == RARCH_DISPLAY_X11)
{
#ifdef HAVE_X11
x11_suspend_screensaver(driver.video_window);
x11_suspend_screensaver(driver->video_window);
#endif
return true;
}

20
gfx/drivers/sdl_gfx.c
View File

@ -218,6 +218,8 @@ static void sdl_render_msg(sdl_video_t *vid, SDL_Surface *buffer,
static void sdl_gfx_set_handles(void)
{
driver_t *driver = driver_get_ptr();
/* SysWMinfo headers are broken on OSX. */
#if defined(_WIN32) || defined(HAVE_X11)
SDL_SysWMinfo info;
@ -227,13 +229,13 @@ static void sdl_gfx_set_handles(void)
return;
#if defined(_WIN32)
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)info.window;
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)info.window;
#elif defined(HAVE_X11)
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)info.info.x11.display;
driver.video_window = (uintptr_t)info.info.x11.window;
driver->display_type = RARCH_DISPLAY_X11;
driver->video_display = (uintptr_t)info.info.x11.display;
driver->video_window = (uintptr_t)info.info.x11.window;
#endif
#endif
}
@ -401,13 +403,15 @@ static bool sdl_gfx_focus(void *data)
static bool sdl_gfx_suppress_screensaver(void *data, bool enable)
{
driver_t *driver = driver_get_ptr();
(void)data;
(void)enable;
#ifdef HAVE_X11
if (driver.display_type == RARCH_DISPLAY_X11)
if (driver->display_type == RARCH_DISPLAY_X11)
{
x11_suspend_screensaver(driver.video_window);
x11_suspend_screensaver(driver->video_window);
return true;
}
#endif

15
gfx/drivers/xvideo.c
View File

@ -416,6 +416,7 @@ static void *xv_init(const video_info_t *video,
XVisualInfo *visualinfo = NULL;
XVisualInfo visualtemplate = {0};
const struct retro_game_geometry *geom = NULL;
driver_t *driver = driver_get_ptr();
xv_t *xv = (xv_t*)calloc(1, sizeof(*xv));
if (!xv)
return NULL;
@ -558,9 +559,9 @@ static void *xv_init(const video_info_t *video,
xv_set_nonblock_state(xv, !video->vsync);
xv->focus = true;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)xv->display;
driver.video_window = (Window)xv->window;
driver->display_type = RARCH_DISPLAY_X11;
driver->video_display = (uintptr_t)xv->display;
driver->video_window = (Window)xv->window;
if (input && input_data)
{
@ -785,6 +786,7 @@ static bool xv_alive(void *data)
{
XEvent event;
xv_t *xv = (xv_t*)data;
driver_t *driver = driver_get_ptr();
while (XPending(xv->display))
{
@ -808,7 +810,7 @@ static bool xv_alive(void *data)
break;
case ButtonPress:
x_input_poll_wheel(driver.input_data, &event.xbutton, true);
x_input_poll_wheel(driver->input_data, &event.xbutton, true);
break;
case ButtonRelease:
break;
@ -838,10 +840,11 @@ static bool xv_suppress_screensaver(void *data, bool enable)
{
(void)data;
(void)enable;
driver_t *driver = driver_get_ptr();
if (driver.display_type == RARCH_DISPLAY_X11)
if (driver->display_type == RARCH_DISPLAY_X11)
{
x11_suspend_screensaver(driver.video_window);
x11_suspend_screensaver(driver->video_window);
return true;
}

40
gfx/drivers_context/androidegl_ctx.c
View File

@ -41,8 +41,10 @@ static bool g_es3;
static void android_gfx_ctx_set_swap_interval(void *data, unsigned interval)
{
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_android_data_t *android = NULL;
android = (gfx_ctx_android_data_t*)driver->video_context_data;
(void)data;
if (!android)
@ -84,8 +86,10 @@ static void android_gfx_ctx_destroy_resources(gfx_ctx_android_data_t *android)
static void android_gfx_ctx_destroy(void *data)
{
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
driver_t *driver = driver_get_ptr;
gfx_ctx_android_data_t *android = NULL;
android = (gfx_ctx_android_data_t*)driver->video_context_data;
(void)data;
if (!android)
@ -93,17 +97,20 @@ static void android_gfx_ctx_destroy(void *data)
android_gfx_ctx_destroy_resources(android);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static void android_gfx_ctx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
EGLint gl_width, gl_height;
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_android_data_t *android = NULL;
android = (gfx_ctx_android_data_t*)
driver->video_context_data;
*width = 0;
*height = 0;
@ -139,6 +146,7 @@ static bool android_gfx_ctx_init(void *data)
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
driver_t *driver = driver_get_ptr();
gfx_ctx_android_data_t *android = NULL;
struct android_app *android_app = (struct android_app*)g_android;
@ -210,7 +218,7 @@ static bool android_gfx_ctx_init(void *data)
android->g_egl_surf, android->g_egl_ctx))
goto error;
driver.video_context_data = android;
driver->video_context_data = android;
return true;
@ -225,8 +233,10 @@ error:
static void android_gfx_ctx_swap_buffers(void *data)
{
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_android_data_t *android = NULL;
android = (gfx_ctx_android_data_t*)driver->video_context_data;
(void)data;
@ -348,8 +358,10 @@ static bool android_gfx_ctx_has_windowed(void *data)
static void android_gfx_ctx_bind_hw_render(void *data, bool enable)
{
gfx_ctx_android_data_t *android = (gfx_ctx_android_data_t*)
driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_android_data_t *android = NULL;
android = (gfx_ctx_android_data_t*)driver->video_context_data;
(void)data;

9
gfx/drivers_context/d3d_ctx.cpp
View File

@ -70,6 +70,8 @@ static void d3d_resize(void *data, unsigned new_width, unsigned new_height)
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
driver_t *driver = driver_get_ptr();
switch (message)
{
case WM_CREATE:
@ -95,13 +97,13 @@ LRESULT CALLBACK WindowProc(HWND hWnd, UINT message,
unsigned new_height = HIWORD(lParam);
if (new_width && new_height)
d3d_resize(driver.video_data, new_width, new_height);
d3d_resize(driver->video_data, new_width, new_height);
}
return 0;
case WM_COMMAND:
if (g_settings.ui.menubar_enable)
{
d3d_video_t *d3d = (d3d_video_t*)driver.video_data;
d3d_video_t *d3d = (d3d_video_t*)driver->video_data;
HWND d3dr = d3d->hWnd;
LRESULT ret = win32_menu_loop(d3dr, wParam);
}
@ -303,7 +305,8 @@ static void gfx_ctx_d3d_check_window(void *data, bool *quit,
#ifdef _XBOX
static HANDLE GetFocus(void)
{
d3d_video_t *d3d = (d3d_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
d3d_video_t *d3d = (d3d_video_t*)driver->video_data;
return d3d->hWnd;
}
#endif

39
gfx/drivers_context/drm_egl_ctx.c
View File

@ -107,7 +107,8 @@ static void sighandler(int sig)
static void gfx_ctx_drm_egl_swap_interval(void *data, unsigned interval)
{
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)driver->video_context_data;
(void)data;
@ -160,8 +161,9 @@ static void wait_flip(bool block)
int timeout = 0;
struct pollfd fds = {0};
drmEventContext evctx = {0};
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
fds.fd = drm->g_drm_fd;
fds.events = POLLIN;
@ -202,8 +204,9 @@ static void queue_flip(void)
{
int ret;
struct drm_fb *fb = NULL;
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
drm->g_next_bo = gbm_surface_lock_front_buffer(drm->g_gbm_surface);
@ -223,8 +226,9 @@ static void queue_flip(void)
static void gfx_ctx_drm_egl_swap_buffers(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -274,7 +278,8 @@ 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*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)driver->video_context_data;
if (!drm)
return;
@ -390,6 +395,7 @@ static bool gfx_ctx_drm_egl_init(void *data)
struct string_list *gpu_descriptors = NULL;
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)calloc(1, sizeof(gfx_ctx_drm_egl_data_t));
driver_t *driver = driver_get_ptr();
if (!drm)
return false;
@ -523,7 +529,7 @@ nextgpu:
dir_list_free(gpu_descriptors);
driver.video_context_data = drm;
driver->video_context_data = drm;
return true;
@ -540,8 +546,9 @@ error:
static void drm_fb_destroy_callback(struct gbm_bo *bo, void *data)
{
driver_t *driver = driver_get_ptr();
struct drm_fb *fb = (struct drm_fb*)data;
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)driver.video_context_data;
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)driver->video_context_data;
if (drm && fb->fb_id)
drmModeRmFB(drm->g_drm_fd, fb->fb_id);
@ -687,8 +694,9 @@ static bool gfx_ctx_drm_egl_set_video_mode(void *data,
int i, ret = 0;
struct sigaction sa = {{0}};
struct drm_fb *fb = NULL;
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
if (!drm)
return false;
@ -841,8 +849,9 @@ error:
static void gfx_ctx_drm_egl_destroy(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
if (!drm)
return;
@ -851,9 +860,9 @@ static void gfx_ctx_drm_egl_destroy(void *data)
gfx_ctx_drm_egl_destroy_resources(drm);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static void gfx_ctx_drm_egl_input_driver(void *data,
@ -866,8 +875,9 @@ static void gfx_ctx_drm_egl_input_driver(void *data,
static bool gfx_ctx_drm_egl_has_focus(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
if (!drm)
@ -925,8 +935,9 @@ static bool gfx_ctx_drm_egl_bind_api(void *data,
static void gfx_ctx_drm_egl_bind_hw_render(void *data, bool enable)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_drm_egl_data_t *drm = (gfx_ctx_drm_egl_data_t*)
driver.video_context_data;
driver->video_context_data;
if (!drm)
return;

69
gfx/drivers_context/glx_ctx.c
View File

@ -73,7 +73,8 @@ static void glx_sighandler(int sig)
static Bool glx_wait_notify(Display *d, XEvent *e, char *arg)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
(void)d;
(void)e;
@ -97,7 +98,8 @@ static void gfx_ctx_glx_destroy(void *data);
static void gfx_ctx_glx_swap_interval(void *data, unsigned interval)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
glx->g_interval = interval;
@ -126,7 +128,8 @@ static void gfx_ctx_glx_check_window(void *data, bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
XEvent event;
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
unsigned new_width = *width, new_height = *height;
(void)frame_count;
@ -169,7 +172,7 @@ static void gfx_ctx_glx_check_window(void *data, bool *quit,
glx->g_has_focus = false;
break;
case ButtonPress:
x_input_poll_wheel(driver.input_data, &event.xbutton, true);
x_input_poll_wheel(driver->input_data, &event.xbutton, true);
break;
case ButtonRelease:
break;
@ -185,7 +188,8 @@ static void gfx_ctx_glx_check_window(void *data, bool *quit,
static void gfx_ctx_glx_swap_buffers(void *data)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
(void)data;
if (glx->g_is_double)
@ -203,11 +207,8 @@ static void gfx_ctx_glx_set_resize(void *data,
static void gfx_ctx_glx_update_window_title(void *data)
{
char buf[128], buf_fps[128];
gfx_ctx_glx_data_t *glx = NULL;
(void)data;
glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
if (video_monitor_get_fps(buf, sizeof(buf),
buf_fps, sizeof(buf_fps)))
@ -219,7 +220,8 @@ static void gfx_ctx_glx_update_window_title(void *data)
static void gfx_ctx_glx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
if (!glx)
return;
@ -252,6 +254,8 @@ static void gfx_ctx_glx_get_video_size(void *data,
static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx)
{
driver_t *driver = driver_get_ptr();
if (!glx)
return;
@ -259,9 +263,11 @@ static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx)
if (glx->g_dpy && glx->g_ctx)
{
glFinish();
glXMakeContextCurrent(glx->g_dpy, None, None, NULL);
if (!driver.video_cache_context)
if (!driver->video_cache_context)
{
if (glx->g_hw_ctx)
glXDestroyContext(glx->g_dpy, glx->g_hw_ctx);
@ -309,7 +315,7 @@ static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx)
glx->g_should_reset_mode = false;
}
if (!driver.video_cache_context && glx->g_dpy)
if (!driver->video_cache_context && glx->g_dpy)
{
XCloseDisplay(glx->g_dpy);
glx->g_dpy = NULL;
@ -340,6 +346,7 @@ static bool gfx_ctx_glx_init(void *data)
int nelements, major, minor;
GLXFBConfig *fbcs = NULL;
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)calloc(1, sizeof(gfx_ctx_glx_data_t));
driver_t *driver = driver_get_ptr();
if (!glx)
return false;
@ -387,7 +394,7 @@ static bool gfx_ctx_glx_init(void *data)
glx->g_fbc = fbcs[0];
XFree(fbcs);
driver.video_context_data = glx;
driver->video_context_data = glx;
return true;
@ -411,7 +418,8 @@ static bool gfx_ctx_glx_set_video_mode(void *data,
XVisualInfo *vi = NULL;
XSetWindowAttributes swa = {0};
int (*old_handler)(Display*, XErrorEvent*) = NULL;
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
struct sigaction sa = {{0}};
sa.sa_handler = glx_sighandler;
@ -572,7 +580,7 @@ static bool gfx_ctx_glx_set_video_mode(void *data,
}
else
{
driver.video_cache_context_ack = true;
driver->video_cache_context_ack = true;
RARCH_LOG("[GLX]: Using cached GL context.\n");
}
@ -623,9 +631,9 @@ static bool gfx_ctx_glx_set_video_mode(void *data,
if (!x11_create_input_context(glx->g_dpy, glx->g_win, &glx->g_xim, &glx->g_xic))
goto error;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)glx->g_dpy;
driver.video_window = (uintptr_t)glx->g_win;
driver->display_type = RARCH_DISPLAY_X11;
driver->video_display = (uintptr_t)glx->g_dpy;
driver->video_window = (uintptr_t)glx->g_win;
glx->g_true_full = true_full;
return true;
@ -644,7 +652,8 @@ error:
static void gfx_ctx_glx_destroy(void *data)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
if (!glx)
return;
@ -653,9 +662,9 @@ static void gfx_ctx_glx_destroy(void *data)
ctx_glx_destroy_resources(glx);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static void gfx_ctx_glx_input_driver(void *data,
@ -673,7 +682,8 @@ static bool gfx_ctx_glx_has_focus(void *data)
{
Window win;
int rev;
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
(void)data;
@ -684,10 +694,11 @@ static bool gfx_ctx_glx_has_focus(void *data)
static bool gfx_ctx_glx_suppress_screensaver(void *data, bool enable)
{
if (driver.display_type != RARCH_DISPLAY_X11)
driver_t *driver = driver_get_ptr();
if (driver->display_type != RARCH_DISPLAY_X11)
return false;
x11_suspend_screensaver(driver.video_window);
x11_suspend_screensaver(driver->video_window);
return true;
}
@ -716,7 +727,8 @@ static bool gfx_ctx_glx_bind_api(void *data, enum gfx_ctx_api api,
static void gfx_ctx_glx_show_mouse(void *data, bool state)
{
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
(void)data;
@ -725,7 +737,8 @@ 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*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_glx_data_t *glx = (gfx_ctx_glx_data_t*)driver->video_context_data;
if (!glx)
return;

20
gfx/drivers_context/ps3_ctx.c
View File

@ -145,7 +145,8 @@ static void gfx_ctx_ps3_get_available_resolutions(void)
static void gfx_ctx_ps3_set_swap_interval(void *data, unsigned interval)
{
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver->video_context_data;
(void)data;
@ -227,7 +228,8 @@ 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*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver->video_context_data;
(void)data;
@ -239,6 +241,7 @@ static void gfx_ctx_ps3_get_video_size(void *data,
static bool gfx_ctx_ps3_init(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)
calloc(1, sizeof(gfx_ctx_ps3_data_t));
@ -304,7 +307,7 @@ static bool gfx_ctx_ps3_init(void *data)
gfx_ctx_ps3_get_available_resolutions();
driver.video_context_data = ps3;
driver->video_context_data = ps3;
return true;
}
@ -332,18 +335,19 @@ static void gfx_ctx_ps3_destroy_resources(gfx_ctx_ps3_data_t *ps3)
static void gfx_ctx_ps3_destroy(void *data)
{
(void)data;
driver_t *driver = driver_get_ptr();
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver->video_context_data;
gfx_ctx_ps3_data_t *ps3 = (gfx_ctx_ps3_data_t*)driver.video_context_data;
(void)data;
if (!ps3)
return;
gfx_ctx_ps3_destroy_resources(ps3);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static void gfx_ctx_ps3_input_driver(void *data,

35
gfx/drivers_context/sdl_gl_ctx.c
View File

@ -68,7 +68,8 @@ static void sdl_ctx_destroy_resources(gfx_ctx_sdl_data_t *sdl)
static bool sdl_ctx_init(void *data)
{
gfx_ctx_sdl_data_t *sdl;
gfx_ctx_sdl_data_t *sdl = NULL;
driver_t *driver = driver_get_ptr();
(void)data;
@ -93,7 +94,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);
driver.video_context_data = sdl;
driver->video_context_data = sdl;
return true;
@ -111,7 +112,8 @@ error:
static void sdl_ctx_destroy(void *data)
{
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
if (!sdl)
return;
@ -120,9 +122,9 @@ static void sdl_ctx_destroy(void *data)
sdl_ctx_destroy_resources(sdl);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static bool sdl_ctx_bind_api(void *data, enum gfx_ctx_api api, unsigned major,
@ -171,7 +173,8 @@ static bool sdl_ctx_set_video_mode(void *data, unsigned width, unsigned height,
bool fullscreen)
{
unsigned fsflag = 0;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
(void)data;
@ -215,7 +218,7 @@ static bool sdl_ctx_set_video_mode(void *data, unsigned width, unsigned height,
#ifdef HAVE_SDL2
if (sdl->g_ctx)
driver.video_cache_context_ack = true;
driver->video_cache_context_ack = true;
else
{
sdl->g_ctx = SDL_GL_CreateContext(sdl->g_win);
@ -239,7 +242,8 @@ error:
static void sdl_ctx_get_video_size(void *data,
unsigned *width, unsigned *height)
{
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
if (!sdl)
return;
@ -276,7 +280,8 @@ static void sdl_ctx_get_video_size(void *data,
static void sdl_ctx_update_window_title(void *data)
{
char buf[128], buf_fps[128];
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
if (!sdl)
return;
@ -298,7 +303,8 @@ 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*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
(void)data;
@ -359,10 +365,12 @@ static void sdl_ctx_set_resize(void *data, unsigned width, unsigned height)
static bool sdl_ctx_has_focus(void *data)
{
unsigned flags;
driver_t *driver = driver_get_ptr();
(void)data;
#ifdef HAVE_SDL2
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver.video_context_data;
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
flags = (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
return (SDL_GetWindowFlags(sdl->g_win) & flags) == flags;
#else
@ -387,7 +395,8 @@ 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*)driver.video_context_data;
driver_t *driver = driver_get_ptr();
gfx_ctx_sdl_data_t *sdl = (gfx_ctx_sdl_data_t*)driver->video_context_data;
SDL_GL_SwapWindow(sdl->g_win);
#else
SDL_GL_SwapBuffers();

51
gfx/drivers_context/wayland_ctx.c
View File

@ -83,8 +83,9 @@ static void shell_surface_handle_configure(void *data,
struct wl_shell_surface *shell_surface,
uint32_t edges, int32_t width, int32_t height)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
(void)shell_surface;
@ -114,8 +115,9 @@ 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)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
(void)version;
@ -236,8 +238,9 @@ static void egl_report_error(void)
static void gfx_ctx_wl_swap_interval(void *data, unsigned interval)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -260,8 +263,9 @@ static void gfx_ctx_wl_swap_interval(void *data, unsigned interval)
static void flush_wayland_fd(void)
{
struct pollfd fd = {0};
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
wl_display_dispatch_pending(wl->g_dpy);
wl_display_flush(wl->g_dpy);
@ -311,8 +315,9 @@ static void gfx_ctx_wl_check_window(void *data, bool *quit,
static void gfx_ctx_wl_swap_buffers(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -321,8 +326,9 @@ static void gfx_ctx_wl_swap_buffers(void *data)
static void gfx_ctx_wl_set_resize(void *data, unsigned width, unsigned height)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -332,8 +338,9 @@ static void gfx_ctx_wl_set_resize(void *data, unsigned width, unsigned height)
static void gfx_ctx_wl_update_window_title(void *data)
{
char buf[128], buf_fps[128];
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -348,8 +355,9 @@ static void gfx_ctx_wl_update_window_title(void *data)
static void gfx_ctx_wl_get_video_size(void *data,
unsigned *width, unsigned *height)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -399,6 +407,7 @@ static bool gfx_ctx_wl_init(void *data)
EGLint egl_major = 0, egl_minor = 0;
EGLint num_configs;
const EGLint *attrib_ptr;
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
calloc(1, sizeof(gfx_ctx_wayland_data_t));
@ -437,7 +446,7 @@ static bool gfx_ctx_wl_init(void *data)
goto error;
}
driver.video_context_data = wl;
driver->video_context_data = wl;
wl->g_registry = wl_display_get_registry(wl->g_dpy);
wl_registry_add_listener(wl->g_registry, &registry_listener, NULL);
@ -493,9 +502,9 @@ error:
if (wl)
free(wl);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
return false;
}
@ -562,8 +571,9 @@ static EGLint *egl_fill_attribs(EGLint *attr)
static void gfx_ctx_wl_destroy(void *data)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -572,17 +582,18 @@ static void gfx_ctx_wl_destroy(void *data)
gfx_ctx_wl_destroy_resources(wl);
if (driver.video_context_data)
free(driver.video_context_data);
driver.video_context_data = NULL;
if (driver->video_context_data)
free(driver->video_context_data);
driver->video_context_data = NULL;
}
static bool gfx_ctx_wl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
struct sigaction sa = {{0}};
sa.sa_handler = sighandler;
@ -714,8 +725,9 @@ static bool gfx_ctx_wl_bind_api(void *data,
static void gfx_ctx_wl_bind_hw_render(void *data, bool enable)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
(void)data;
@ -843,8 +855,9 @@ static const struct wl_pointer_listener pointer_listener = {
static void seat_handle_capabilities(void *data,
struct wl_seat *seat, unsigned caps)
{
driver_t *driver = driver_get_ptr();
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)
driver.video_context_data;
driver->video_context_data;
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !wl->g_wl_keyboard)
{

14
gfx/drivers_context/wgl_ctx.c
View File

@ -106,6 +106,7 @@ static void create_gl_context(HWND hwnd)
{
bool core_context;
bool debug = g_extern.system.hw_render_callback.debug_context;
driver_t *driver = driver_get_ptr();
#ifdef _WIN32
dll_handle = LoadLibrary("OpenGL32.dll");
@ -122,7 +123,7 @@ static void create_gl_context(HWND hwnd)
if (g_hrc)
{
RARCH_LOG("[WGL]: Using cached GL context.\n");
driver.video_cache_context_ack = true;
driver->video_cache_context_ack = true;
}
else
{
@ -466,6 +467,7 @@ static bool gfx_ctx_wgl_set_video_mode(void *data,
bool windowed_full;
RECT rect = {0};
HMONITOR hm_to_use = NULL;
driver_t *driver = driver_get_ptr();
monitor_info(&current_mon, &hm_to_use);
mon_rect = current_mon.rcMonitor;
@ -548,9 +550,9 @@ static bool gfx_ctx_wgl_set_video_mode(void *data,
gfx_ctx_wgl_swap_interval(data, g_interval);
driver.display_type = RARCH_DISPLAY_WIN32;
driver.video_display = 0;
driver.video_window = (uintptr_t)g_hwnd;
driver->display_type = RARCH_DISPLAY_WIN32;
driver->video_display = 0;
driver->video_window = (uintptr_t)g_hwnd;
return true;
@ -561,6 +563,8 @@ error:
static void gfx_ctx_wgl_destroy(void *data)
{
driver_t *driver = driver_get_ptr();
(void)data;
if (g_hrc)
@ -568,7 +572,7 @@ static void gfx_ctx_wgl_destroy(void *data)
glFinish();
wglMakeCurrent(NULL, NULL);
if (!driver.video_cache_context)
if (!driver->video_cache_context)
{
if (g_hw_hrc)
wglDeleteContext(g_hw_hrc);

16
gfx/drivers_context/xegl_ctx.c
View File

@ -144,6 +144,7 @@ static void gfx_ctx_xegl_check_window(void *data, bool *quit,
XEvent event;
unsigned new_width = *width;
unsigned new_height = *height;
driver_t *driver = driver_get_ptr();
(void)frame_count;
@ -187,7 +188,7 @@ static void gfx_ctx_xegl_check_window(void *data, bool *quit,
break;
case ButtonPress:
x_input_poll_wheel(driver.input_data, &event.xbutton, true);
x_input_poll_wheel(driver->input_data, &event.xbutton, true);
break;
case ButtonRelease:
@ -453,6 +454,7 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
XVisualInfo temp = {0};
XSetWindowAttributes swa = {0};
XVisualInfo *vi = NULL;
driver_t *driver = driver_get_ptr();
sa.sa_handler = egl_sighandler;
sa.sa_flags = SA_RESTART;
@ -613,9 +615,9 @@ static bool gfx_ctx_xegl_set_video_mode(void *data,
if (!x11_create_input_context(g_dpy, g_win, &g_xim, &g_xic))
goto error;
driver.display_type = RARCH_DISPLAY_X11;
driver.video_display = (uintptr_t)g_dpy;
driver.video_window = (uintptr_t)g_win;
driver->display_type = RARCH_DISPLAY_X11;
driver->video_display = (uintptr_t)g_dpy;
driver->video_window = (uintptr_t)g_win;
g_true_full = true_full;
return true;
@ -727,13 +729,15 @@ static bool gfx_ctx_xegl_has_focus(void *data)
static bool gfx_ctx_xegl_suppress_screensaver(void *data, bool enable)
{
driver_t *driver = driver_get_ptr();
(void)data;
(void)enable;
if (driver.display_type != RARCH_DISPLAY_X11)
if (driver->display_type != RARCH_DISPLAY_X11)
return false;
x11_suspend_screensaver(driver.video_window);
x11_suspend_screensaver(driver->video_window);
return true;
}

39
gfx/drivers_shader/shader_gl_cg.c
View File

@ -171,7 +171,8 @@ static void gl_cg_reset_attrib(cg_shader_data_t *cg)
static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
(void)data;
@ -199,7 +200,8 @@ static bool gl_cg_set_mvp(void *data, const math_matrix_4x4 *mat)
static bool gl_cg_set_coords(const void *data)
{
const struct gl_coords *coords = (const struct gl_coords*)data;
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (!cg || !coords)
goto fallback;
@ -235,7 +237,8 @@ static void gl_cg_set_params(void *data, unsigned width, unsigned height,
const struct gl_tex_info *info = (const struct gl_tex_info*)_info;
const struct gl_tex_info *prev_info = (const struct gl_tex_info*)_prev_info;
const struct gl_tex_info *fbo_info = (const struct gl_tex_info*)_fbo_info;
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
(void)data;
if (!cg || (cg->active_idx == 0) ||
@ -473,7 +476,8 @@ static void gl_cg_deinit_context_state(cg_shader_data_t *cg)
/* Full deinit. */
static void gl_cg_deinit(void)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (!cg)
return;
@ -889,6 +893,7 @@ static bool gl_cg_init(void *data, const char *path)
(void)data;
cg_shader_data_t *cg = (cg_shader_data_t*)
calloc(1, sizeof(cg_shader_data_t));
driver_t *driver = driver_get_ptr();
if (!cg)
return false;
@ -960,7 +965,7 @@ static bool gl_cg_init(void *data, const char *path)
cgGLBindProgram(cg->prg[1].fprg);
cgGLBindProgram(cg->prg[1].vprg);
driver.video_shader_data = cg;
driver->video_shader_data = cg;
return true;
@ -973,7 +978,8 @@ error:
static void gl_cg_use(void *data, unsigned idx)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
(void)data;
if (cg && cg->prg[idx].vprg && cg->prg[idx].fprg)
@ -988,7 +994,8 @@ static void gl_cg_use(void *data, unsigned idx)
static unsigned gl_cg_num(void)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (!cg)
return 0;
return cg->cg_shader->passes;
@ -996,7 +1003,8 @@ static unsigned gl_cg_num(void)
static bool gl_cg_filter_type(unsigned idx, bool *smooth)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (cg && idx &&
(cg->cg_shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
)
@ -1010,7 +1018,8 @@ static bool gl_cg_filter_type(unsigned idx, bool *smooth)
static enum gfx_wrap_type gl_cg_wrap_type(unsigned idx)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (cg && idx)
return cg->cg_shader->pass[idx - 1].wrap;
return RARCH_WRAP_BORDER;
@ -1018,7 +1027,8 @@ static enum gfx_wrap_type gl_cg_wrap_type(unsigned idx)
static void gl_cg_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (cg && idx)
*scale = cg->cg_shader->pass[idx - 1].fbo;
else
@ -1029,7 +1039,8 @@ static unsigned gl_cg_get_prev_textures(void)
{
unsigned i, j;
unsigned max_prev = 0;
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (!cg)
return 0;
@ -1044,7 +1055,8 @@ static unsigned gl_cg_get_prev_textures(void)
static bool gl_cg_mipmap_input(unsigned idx)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (cg && idx)
return cg->cg_shader->pass[idx - 1].mipmap;
return false;
@ -1052,7 +1064,8 @@ static bool gl_cg_mipmap_input(unsigned idx)
static struct video_shader *gl_cg_get_current_shader(void)
{
cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
cg_shader_data_t *cg = (cg_shader_data_t*)driver->video_shader_data;
if (!cg)
return NULL;
return cg->cg_shader;

46
gfx/drivers_shader/shader_glsl.c
View File

@ -693,16 +693,17 @@ static void gl_glsl_destroy_resources(glsl_shader_data_t *glsl)
static void gl_glsl_deinit(void)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return;
gl_glsl_destroy_resources(glsl);
if (driver.video_shader_data)
free(driver.video_shader_data);
driver.video_shader_data = NULL;
if (driver->video_shader_data)
free(driver->video_shader_data);
driver->video_shader_data = NULL;
}
static bool gl_glsl_init(void *data, const char *path)
@ -712,6 +713,7 @@ static bool gl_glsl_init(void *data, const char *path)
glsl_shader_data_t *glsl = NULL;
const char *stock_vertex = NULL;
const char *stock_fragment = NULL;
driver_t *driver = driver_get_ptr();
(void)data;
@ -913,7 +915,7 @@ static bool gl_glsl_init(void *data, const char *path)
glGenBuffers(1, &glsl->glsl_vbo[i].vbo_secondary);
}
driver.video_shader_data = glsl;
driver->video_shader_data = glsl;
return true;
@ -944,7 +946,8 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
const struct gl_tex_info *prev_info = (const struct gl_tex_info*)_prev_info;
const struct gl_tex_info *fbo_info = (const struct gl_tex_info*)_fbo_info;
struct glsl_attrib *attr = (struct glsl_attrib*)attribs;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return;
@ -1132,7 +1135,8 @@ static void gl_glsl_set_params(void *data, unsigned width, unsigned height,
static bool gl_glsl_set_mvp(void *data, const math_matrix_4x4 *mat)
{
int loc;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
(void)data;
@ -1161,7 +1165,8 @@ static bool gl_glsl_set_coords(const void *data)
struct glsl_attrib *attr = NULL;
const struct shader_uniforms *uni = NULL;
const struct gl_coords *coords = (const struct gl_coords*)data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl || !glsl->glsl_shader->modern || !coords)
{
@ -1257,7 +1262,8 @@ static bool gl_glsl_set_coords(const void *data)
static void gl_glsl_use(void *data, unsigned idx)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
(void)data;
@ -1272,7 +1278,8 @@ static void gl_glsl_use(void *data, unsigned idx)
static unsigned gl_glsl_num(void)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && glsl->glsl_shader)
return glsl->glsl_shader->passes;
return 0;
@ -1280,7 +1287,8 @@ static unsigned gl_glsl_num(void)
static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx
&& (glsl->glsl_shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC)
)
@ -1293,7 +1301,8 @@ static bool gl_glsl_filter_type(unsigned idx, bool *smooth)
static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
return glsl->glsl_shader->pass[idx - 1].wrap;
return RARCH_WRAP_BORDER;
@ -1301,7 +1310,8 @@ static enum gfx_wrap_type gl_glsl_wrap_type(unsigned idx)
static void gl_glsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
*scale = glsl->glsl_shader->pass[idx - 1].fbo;
else
@ -1312,8 +1322,8 @@ static unsigned gl_glsl_get_prev_textures(void)
{
unsigned i, j;
unsigned max_prev = 0;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return 0;
@ -1328,7 +1338,8 @@ static unsigned gl_glsl_get_prev_textures(void)
static bool gl_glsl_mipmap_input(unsigned idx)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (glsl && idx)
return glsl->glsl_shader->pass[idx - 1].mipmap;
return false;
@ -1336,7 +1347,8 @@ static bool gl_glsl_mipmap_input(unsigned idx)
static struct video_shader *gl_glsl_get_current_shader(void)
{
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
glsl_shader_data_t *glsl = (glsl_shader_data_t*)driver->video_shader_data;
if (!glsl)
return NULL;
return glsl->glsl_shader;

33
gfx/drivers_shader/shader_hlsl.c
View File

@ -90,7 +90,8 @@ typedef struct hlsl_shader_data
void hlsl_set_proj_matrix(XMMATRIX rotation_value)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (hlsl)
hlsl->prg[hlsl->active_idx].mvp_val = rotation_value;
}
@ -113,7 +114,8 @@ static void hlsl_set_params(void *data, unsigned width, unsigned height,
const struct gl_tex_info *info = (const struct gl_tex_info*)_info;
const struct gl_tex_info *prev_info = (const struct gl_tex_info*)_prev_info;
const struct gl_tex_info *fbo_info = (const struct gl_tex_info*)_fbo_info;
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (!hlsl)
return;
@ -352,6 +354,7 @@ static bool hlsl_init(void *data, const char *path)
d3d_video_t *d3d = (d3d_video_t*)data;
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)
calloc(1, sizeof(hlsl_shader_data_t));
driver_t *driver = driver_get_ptr();
if (!hlsl)
return false;
@ -373,7 +376,7 @@ static bool hlsl_init(void *data, const char *path)
d3d_set_vertex_shader(d3d->dev, 1, hlsl->prg[1].vprg);
d3d->dev->SetPixelShader(hlsl->prg[1].fprg);
driver.video_shader_data = hlsl;
driver->video_shader_data = hlsl;
return true;
@ -386,22 +389,24 @@ error:
// Full deinit.
static void hlsl_deinit(void)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (!hlsl)
return;
hlsl_deinit_state(hlsl);
if (driver.video_shader_data)
free(driver.video_shader_data);
driver.video_shader_data = NULL;
if (driver->video_shader_data)
free(driver->video_shader_data);
driver->video_shader_data = NULL;
}
static void hlsl_use(void *data, unsigned idx)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (hlsl && hlsl->prg[idx].vprg && hlsl->prg[idx].fprg)
{
@ -417,7 +422,8 @@ static void hlsl_use(void *data, unsigned idx)
static unsigned hlsl_num(void)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (hlsl)
return hlsl->cg_shader->passes;
return 0;
@ -425,7 +431,8 @@ static unsigned hlsl_num(void)
static bool hlsl_filter_type(unsigned idx, bool *smooth)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (hlsl && idx
&& (hlsl->cg_shader->pass[idx - 1].filter != RARCH_FILTER_UNSPEC))
{
@ -437,7 +444,8 @@ static bool hlsl_filter_type(unsigned idx, bool *smooth)
static void hlsl_shader_scale(unsigned idx, struct gfx_fbo_scale *scale)
{
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if (hlsl && idx)
*scale = hlsl->cg_shader->pass[idx - 1].fbo;
else
@ -448,7 +456,8 @@ static bool hlsl_set_mvp(void *data, const math_matrix_4x4 *mat)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3d_device_ptr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver.video_shader_data;
driver_t *driver = driver_get_ptr();
hlsl_shader_data_t *hlsl = (hlsl_shader_data_t*)driver->video_shader_data;
if(hlsl && hlsl->prg[hlsl->active_idx].mvp)
{

5
gfx/gl_common.c
View File

@ -27,6 +27,7 @@ void gl_load_texture_data(GLuint id,
GLenum wrap;
bool want_mipmap = false;
bool rgb32 = (base_size == (sizeof(uint32_t)));
driver_t *driver = driver_get_ptr();
glBindTexture(GL_TEXTURE_2D, id);
@ -70,9 +71,9 @@ void gl_load_texture_data(GLuint id,
#endif
glTexImage2D(GL_TEXTURE_2D,
0,
(driver.gfx_use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_INTERNAL_FORMAT32,
(driver->gfx_use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_INTERNAL_FORMAT32,
width, height, 0,
(driver.gfx_use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_TEXTURE_TYPE32,
(driver->gfx_use_rgba || !rgb32) ? GL_RGBA : RARCH_GL_TEXTURE_TYPE32,
(rgb32) ? RARCH_GL_FORMAT32 : GL_UNSIGNED_SHORT_4_4_4_4, frame);
if (want_mipmap)

9
gfx/image/image.c
View File

@ -158,7 +158,10 @@ void texture_image_free(struct texture_image *img)
bool texture_image_load(struct texture_image *out_img, const char *path)
{
D3DXIMAGE_INFO m_imageInfo;
d3d_video_t *d3d = (d3d_video_t*)driver.video_data;
d3d_video_t *d3d = NULL;
driver_t *driver = driver_get_ptr();
d3d = (d3d_video_t*)driver->video_data;
out_img->vertex_buf = NULL;
@ -355,9 +358,11 @@ bool texture_image_load(struct texture_image *out_img, const char *path)
#else
bool texture_image_load(struct texture_image *out_img, const char *path)
{
driver_t *driver = driver_get_ptr();
/* This interface "leak" is very ugly. FIXME: Fix this properly ... */
bool ret = false;
bool use_rgba = driver.gfx_use_rgba;
bool use_rgba = driver->gfx_use_rgba;
unsigned a_shift = 24;
unsigned r_shift = use_rgba ? 0 : 16;
unsigned g_shift = 8;

125
gfx/video_driver.c
View File

@ -148,28 +148,30 @@ const char* config_get_video_driver_options(void)
void find_video_driver(void)
{
int i;
driver_t *driver = driver_get_ptr();
#if defined(HAVE_OPENGL) && defined(HAVE_FBO)
if (g_extern.system.hw_render_callback.context_type)
{
RARCH_LOG("Using HW render, OpenGL driver forced.\n");
driver.video = &video_gl;
driver->video = &video_gl;
return;
}
#endif
if (driver.frontend_ctx &&
driver.frontend_ctx->get_video_driver)
if (driver->frontend_ctx &&
driver->frontend_ctx->get_video_driver)
{
driver.video = driver.frontend_ctx->get_video_driver();
driver->video = driver->frontend_ctx->get_video_driver();
if (driver.video)
if (driver->video)
return;
RARCH_WARN("Frontend supports get_video_driver() but did not specify one.\n");
}
i = find_driver_index("video_driver", g_settings.video.driver);
if (i >= 0)
driver.video = (const video_driver_t*)video_driver_find_handle(i);
driver->video = (const video_driver_t*)video_driver_find_handle(i);
else
{
unsigned d;
@ -180,9 +182,9 @@ void find_video_driver(void)
RARCH_LOG_OUTPUT("\t%s\n", video_driver_find_ident(d));
RARCH_WARN("Going to default to first video driver...\n");
driver.video = (const video_driver_t*)video_driver_find_handle(0);
driver->video = (const video_driver_t*)video_driver_find_handle(0);
if (!driver.video)
if (!driver->video)
rarch_fail(1, "find_video_driver()");
}
}
@ -198,15 +200,16 @@ void find_video_driver(void)
**/
void *video_driver_resolve(const video_driver_t **drv)
{
driver_t *driver = driver_get_ptr();
#ifdef HAVE_THREADS
if (g_settings.video.threaded
&& !g_extern.system.hw_render_callback.context_type)
return rarch_threaded_video_resolve(drv);
#endif
if (drv)
*drv = driver.video;
*drv = driver->video;
return driver.video_data;
return driver->video_data;
}
/**
@ -220,34 +223,38 @@ void *video_driver_resolve(const video_driver_t **drv)
uintptr_t video_driver_get_current_framebuffer(void)
{
#ifdef HAVE_FBO
if (driver.video_poke && driver.video_poke->get_current_framebuffer)
return driver.video_poke->get_current_framebuffer(driver.video_data);
driver_t *driver = driver_get_ptr();
if (driver->video_poke && driver->video_poke->get_current_framebuffer)
return driver->video_poke->get_current_framebuffer(driver->video_data);
#endif
return 0;
}
retro_proc_address_t video_driver_get_proc_address(const char *sym)
{
if (driver.video_poke && driver.video_poke->get_proc_address)
return driver.video_poke->get_proc_address(driver.video_data, sym);
driver_t *driver = driver_get_ptr();
if (driver->video_poke && driver->video_poke->get_proc_address)
return driver->video_poke->get_proc_address(driver->video_data, sym);
return NULL;
}
bool video_driver_is_alive(void)
{
driver_t *driver = driver_get_ptr();
/* Possible race issue, return true */
if (!driver.video || !driver.video_data)
if (!driver->video || !driver->video_data)
return true;
if (!driver.video->alive(driver.video_data))
if (!driver->video->alive(driver->video_data))
return false;
return true;
}
bool video_driver_has_focus(void)
{
if (!driver.video || !driver.video_data)
driver_t *driver = driver_get_ptr();
if (!driver->video || !driver->video_data)
return false;
if (!driver.video->focus(driver.video_data))
if (!driver->video->focus(driver->video_data))
return false;
return true;
}
@ -255,9 +262,10 @@ bool video_driver_has_focus(void)
bool video_driver_set_shader(enum rarch_shader_type type,
const char *shader)
{
if (!driver.video || !driver.video_data)
driver_t *driver = driver_get_ptr();
if (!driver->video || !driver->video_data)
return false;
if (!driver.video->set_shader(driver.video_data, type, shader))
if (!driver->video->set_shader(driver->video_data, type, shader))
return false;
return true;
}
@ -331,16 +339,18 @@ error:
static void init_video_input(const input_driver_t *tmp)
{
driver_t *driver = driver_get_ptr();
/* Video driver didn't provide an input driver,
* so we use configured one. */
RARCH_LOG("Graphics driver did not initialize an input driver. Attempting to pick a suitable driver.\n");
if (tmp)
driver.input = tmp;
driver->input = tmp;
else
find_input_driver();
if (!driver.input)
if (!driver->input)
{
/* This should never really happen as tmp (driver.input) is always
* found before this in find_driver_input(), or we have aborted
@ -348,9 +358,9 @@ static void init_video_input(const input_driver_t *tmp)
rarch_fail(1, "init_video_input()");
}
driver.input_data = driver.input->init();
driver->input_data = driver->input->init();
if (driver.input_data)
if (driver->input_data)
return;
RARCH_ERR("Cannot initialize input driver. Exiting ...\n");
@ -359,21 +369,23 @@ static void init_video_input(const input_driver_t *tmp)
void uninit_video_input(void)
{
driver_t *driver = driver_get_ptr();
rarch_main_command(RARCH_CMD_OVERLAY_DEINIT);
if (
!driver.input_data_own &&
(driver.input_data != driver.video_data) &&
driver.input &&
driver.input->free)
driver.input->free(driver.input_data);
!driver->input_data_own &&
(driver->input_data != driver->video_data) &&
driver->input &&
driver->input->free)
driver->input->free(driver->input_data);
if (
!driver.video_data_own &&
driver.video_data &&
driver.video &&
driver.video->free)
driver.video->free(driver.video_data);
!driver->video_data_own &&
driver->video_data &&
driver->video &&
driver->video->free)
driver->video->free(driver->video_data);
deinit_pixel_converter();
@ -392,6 +404,7 @@ void init_video(void)
video_info_t video = {0};
static uint16_t dummy_pixels[32] = {0};
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
init_video_filter(g_extern.system.pix_fmt);
rarch_main_command(RARCH_CMD_SHADER_DIR_INIT);
@ -449,9 +462,9 @@ void init_video(void)
else
RARCH_LOG("Video @ fullscreen\n");
driver.display_type = RARCH_DISPLAY_NONE;
driver.video_display = 0;
driver.video_window = 0;
driver->display_type = RARCH_DISPLAY_NONE;
driver->video_display = 0;
driver->video_window = 0;
if (!init_video_pixel_converter(RARCH_SCALE_BASE * scale))
{
@ -474,7 +487,7 @@ void init_video(void)
g_extern.filter.out_rgb32 :
(g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888);
tmp = (const input_driver_t*)driver.input;
tmp = (const input_driver_t*)driver->input;
/* Need to grab the "real" video driver interface on a reinit. */
find_video_driver();
@ -484,9 +497,9 @@ void init_video(void)
/* Can't do hardware rendering with threaded driver currently. */
RARCH_LOG("Starting threaded video driver ...\n");
if (!rarch_threaded_video_init(&driver.video, &driver.video_data,
&driver.input, &driver.input_data,
driver.video, &video))
if (!rarch_threaded_video_init(&driver->video, &driver->video_data,
&driver->input, &driver->input_data,
driver->video, &video))
{
RARCH_ERR("Cannot open threaded video driver ... Exiting ...\n");
rarch_fail(1, "init_video()");
@ -494,37 +507,37 @@ void init_video(void)
}
else
#endif
driver.video_data = driver.video->init(&video, &driver.input,
&driver.input_data);
driver->video_data = driver->video->init(&video, &driver->input,
&driver->input_data);
if (!driver.video_data)
if (!driver->video_data)
{
RARCH_ERR("Cannot open video driver ... Exiting ...\n");
rarch_fail(1, "init_video()");
}
driver.video_poke = NULL;
if (driver.video->poke_interface)
driver.video->poke_interface(driver.video_data, &driver.video_poke);
driver->video_poke = NULL;
if (driver->video->poke_interface)
driver->video->poke_interface(driver->video_data, &driver->video_poke);
if (driver.video->viewport_info && (!custom_vp->width ||
if (driver->video->viewport_info && (!custom_vp->width ||
!custom_vp->height))
{
/* Force custom viewport to have sane parameters. */
custom_vp->width = width;
custom_vp->height = height;
driver.video->viewport_info(driver.video_data, custom_vp);
driver->video->viewport_info(driver->video_data, custom_vp);
}
if (driver.video->set_rotation)
driver.video->set_rotation(driver.video_data,
if (driver->video->set_rotation)
driver->video->set_rotation(driver->video_data,
(g_settings.video.rotation + g_extern.system.rotation) % 4);
if (driver.video->suppress_screensaver)
driver.video->suppress_screensaver(driver.video_data,
if (driver->video->suppress_screensaver)
driver->video->suppress_screensaver(driver->video_data,
g_settings.ui.suspend_screensaver_enable);
if (!driver.input)
if (!driver->input)
init_video_input(tmp);
rarch_main_command(RARCH_CMD_OVERLAY_DEINIT);
@ -538,8 +551,8 @@ void init_video(void)
g_extern.frame_cache.data = &dummy_pixels;
#if defined(PSP)
if (driver.video_poke && driver.video_poke->set_texture_frame)
driver.video_poke->set_texture_frame(driver.video_data,
if (driver->video_poke && driver->video_poke->set_texture_frame)
driver->video_poke->set_texture_frame(driver->video_data,
&dummy_pixels, false, 1, 1, 1.0f);
#endif
}

22
gfx/video_pixel_converter.c
View File

@ -20,14 +20,18 @@
void deinit_pixel_converter(void)
{
scaler_ctx_gen_reset(&driver.scaler);
memset(&driver.scaler, 0, sizeof(driver.scaler));
free(driver.scaler_out);
driver.scaler_out = NULL;
driver_t *driver = driver_get_ptr();
scaler_ctx_gen_reset(&driver->scaler);
memset(&driver->scaler, 0, sizeof(driver->scaler));
free(driver->scaler_out);
driver->scaler_out = NULL;
}
bool init_video_pixel_converter(unsigned size)
{
driver_t *driver = driver_get_ptr();
/* This function can be called multiple times
* without deiniting first on consoles. */
deinit_pixel_converter();
@ -39,16 +43,16 @@ bool init_video_pixel_converter(unsigned size)
RARCH_WARN("0RGB1555 pixel format is deprecated, and will be slower. For 15/16-bit, RGB565 format is preferred.\n");
driver.scaler.scaler_type = SCALER_TYPE_POINT;
driver.scaler.in_fmt = SCALER_FMT_0RGB1555;
driver->scaler.scaler_type = SCALER_TYPE_POINT;
driver->scaler.in_fmt = SCALER_FMT_0RGB1555;
/* TODO: Pick either ARGB8888 or RGB565 depending on driver. */
driver.scaler.out_fmt = SCALER_FMT_RGB565;
driver->scaler.out_fmt = SCALER_FMT_RGB565;
if (!scaler_ctx_gen_filter(&driver.scaler))
if (!scaler_ctx_gen_filter(&driver->scaler))
return false;
driver.scaler_out = calloc(sizeof(uint16_t), size * size);
driver->scaler_out = calloc(sizeof(uint16_t), size * size);
return true;
}

9
gfx/video_shader_driver.c
View File

@ -71,11 +71,12 @@ const shader_backend_t *shader_ctx_init_first(void)
struct video_shader *video_shader_driver_get_current_shader(void)
{
if (!driver.video_poke)
driver_t *driver = driver_get_ptr();
if (!driver->video_poke)
return NULL;
if (!driver.video_data)
if (!driver->video_data)
return NULL;
if (!driver.video_poke->get_current_shader)
if (!driver->video_poke->get_current_shader)
return NULL;
return driver.video_poke->get_current_shader(driver.video_data);
return driver->video_poke->get_current_shader(driver->video_data);
}

12
gfx/video_state_python.c
View File

@ -109,10 +109,11 @@ static PyObject *py_read_input(PyObject *self, PyObject *args)
{
unsigned user, key;
int16_t res = 0;
driver_t *driver = driver_get_ptr();
(void)self;
if (!driver.input_data)
if (!driver->input_data)
return PyBool_FromLong(0);
if (!PyArg_ParseTuple(args, "II", &user, &key))
@ -121,8 +122,8 @@ static PyObject *py_read_input(PyObject *self, PyObject *args)
if (user > MAX_USERS || user < 1 || key >= RARCH_FIRST_META_KEY)
return NULL;
if (!driver.block_libretro_input)
res = driver.input->input_state(driver.input_data,
if (!driver->block_libretro_input)
res = driver->input->input_state(driver->input_data,
py_binds, user - 1, RETRO_DEVICE_JOYPAD, 0, key);
return PyBool_FromLong(res);
}
@ -131,10 +132,11 @@ static PyObject *py_read_analog(PyObject *self, PyObject *args)
{
unsigned user, index, id;
int16_t res = 0;
driver_t *driver = driver_get_ptr();
(void)self;
if (!driver.input_data)
if (!driver->input_data)
return PyBool_FromLong(0);
if (!PyArg_ParseTuple(args, "III", &user, &index, &id))
@ -143,7 +145,7 @@ static PyObject *py_read_analog(PyObject *self, PyObject *args)
if (user > MAX_USERS || user < 1 || index > 1 || id > 1)
return NULL;
res = driver.input->input_state(driver.input_data,
res = driver->input->input_state(driver->input_data,
py_binds, user - 1, RETRO_DEVICE_ANALOG, index, id);
return PyFloat_FromDouble((double)res / 0x7fff);
}

13
gfx/video_state_tracker.c
View File

@ -280,8 +280,9 @@ static void state_tracker_update_input(state_tracker_t *tracker)
g_settings.input.binds[0],
g_settings.input.binds[1],
};
driver_t *driver = driver_get_ptr();
if (!driver.input)
if (!driver->input)
return;
for (i = 0; i < 2; i++)
@ -291,15 +292,15 @@ static void state_tracker_update_input(state_tracker_t *tracker)
input_push_analog_dpad(g_settings.input.autoconf_binds[i],
g_settings.input.analog_dpad_mode[i]);
if (!driver.block_libretro_input)
if (!driver->block_libretro_input)
{
for (i = 4; i < 16; i++)
{
state[0] |= (driver.input->input_state(
driver.input_data, binds, 0,
state[0] |= (driver->input->input_state(
driver->input_data, binds, 0,
RETRO_DEVICE_JOYPAD, 0, buttons[i - 4]) ? 1 : 0) << i;
state[1] |= (driver.input->input_state(
driver.input_data, binds, 1,
state[1] |= (driver->input->input_state(
driver->input_data, binds, 1,
RETRO_DEVICE_JOYPAD, 0, buttons[i - 4]) ? 1 : 0) << i;
}
}

3
gfx/video_thread_wrapper.c
View File

@ -1051,7 +1051,8 @@ bool rarch_threaded_video_init(const video_driver_t **out_driver,
**/
void *rarch_threaded_video_resolve(const video_driver_t **drv)
{
const thread_video_t *thr = (const thread_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
const thread_video_t *thr = (const thread_video_t*)driver->video_data;
if (drv)
*drv = thr->driver;

8
input/drivers/linuxraw_input.c
View File

@ -39,6 +39,7 @@ typedef struct linuxraw_input
static void linuxraw_resetKbmd(void)
{
driver_t *driver = driver_get_ptr();
if (oldKbmd != 0xffff)
{
ioctl(0, KDSKBMODE, oldKbmd);
@ -46,7 +47,7 @@ static void linuxraw_resetKbmd(void)
oldKbmd = 0xffff;
}
driver.stdin_claimed = false;
driver->stdin_claimed = false;
}
static void linuxraw_exitGracefully(int sig)
@ -59,12 +60,13 @@ static void *linuxraw_input_init(void)
{
struct sigaction sa;
linuxraw_input_t *linuxraw = NULL;
driver_t *driver = driver_get_ptr();
/* Only work on terminals. */
if (!isatty(0))
return NULL;
if (driver.stdin_claimed)
if (driver->stdin_claimed)
{
RARCH_WARN("stdin is already used for content loading. Cannot use stdin for input.\n");
return NULL;
@ -119,7 +121,7 @@ static void *linuxraw_input_init(void)
/* We need to disable use of stdin command interface if
* stdin is supposed to be used for input. */
driver.stdin_claimed = true;
driver->stdin_claimed = true;
return linuxraw;
}

5
input/drivers/sdl_input.c
View File

@ -268,12 +268,13 @@ static void sdl_grab_mouse(void *data, bool state)
SDL_Window *w;
};
sdl_input_t *sdl = (sdl_input_t*)data;
driver_t *driver = driver_get_ptr();
if (driver.video != &video_sdl2)
if (driver->video != &video_sdl2)
return;
/* First member of sdl2_video_t is the window */
SDL_SetWindowGrab(((struct temp*)driver.video_data)->w,
SDL_SetWindowGrab(((struct temp*)driver->video_data)->w,
state ? SDL_TRUE : SDL_FALSE);
}
#endif

17
input/drivers/x11_input.c
View File

@ -47,7 +47,8 @@ typedef struct x11_input
static void *x_input_init(void)
{
if (driver.display_type != RARCH_DISPLAY_X11)
driver_t *driver = driver_get_ptr();
if (driver->display_type != RARCH_DISPLAY_X11)
{
RARCH_ERR("Currently active window is not an X11 window. Cannot use this driver.\n");
return NULL;
@ -58,8 +59,8 @@ static void *x_input_init(void)
return NULL;
/* Borrow the active X window ... */
x11->display = (Display*)driver.video_display;
x11->win = (Window)driver.video_window;
x11->display = (Display*)driver->video_display;
x11->win = (Window)driver->video_window;
x11->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
input_keymaps_init_keyboard_lut(rarch_key_map_x11);
@ -270,6 +271,7 @@ static void x_input_poll_mouse(x11_input_t *x11)
Window root_win, child_win;
int root_x, root_y, win_x, win_y;
unsigned mask;
driver_t *driver = driver_get_ptr();
x11->mouse_last_x = x11->mouse_x;
x11->mouse_last_y = x11->mouse_y;
@ -288,12 +290,12 @@ static void x_input_poll_mouse(x11_input_t *x11)
x11->mouse_r = mask & Button3Mask;
/* Somewhat hacky, but seem to do the job. */
if (x11->grab_mouse && driver.video->focus(driver.video_data))
if (x11->grab_mouse && driver->video->focus(driver->video_data))
{
struct video_viewport vp = {0};
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (driver->video && driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
int mid_w = vp.full_width >> 1;
int mid_h = vp.full_height >> 1;
@ -329,8 +331,9 @@ void x_input_poll_wheel(void *data, XButtonEvent *event, bool latch)
static void x_input_poll(void *data)
{
x11_input_t *x11 = (x11_input_t*)data;
driver_t *driver = driver_get_ptr();
if (driver.video->focus(driver.video_data))
if (driver->video->focus(driver->video_data))
XQueryKeymap(x11->display, x11->state);
else
memset(x11->state, 0, sizeof(x11->state));

7
input/input_common.c
View File

@ -133,12 +133,15 @@ bool input_translate_coord_viewport(int mouse_x, int mouse_y,
{
int scaled_screen_x, scaled_screen_y, scaled_x, scaled_y;
struct video_viewport vp = {0};
bool have_viewport_info = driver.video && driver.video->viewport_info;
bool have_viewport_info = false;
driver_t *driver = driver_get_ptr();
have_viewport_info = driver->video && driver->video->viewport_info;
if (!have_viewport_info)
return false;
driver.video->viewport_info(driver.video_data, &vp);
driver->video->viewport_info(driver->video_data, &vp);
scaled_screen_x = (2 * mouse_x * 0x7fff) / (int)vp.full_width - 0x7fff;
scaled_screen_y = (2 * mouse_y * 0x7fff) / (int)vp.full_height - 0x7fff;

26
input/input_driver.c
View File

@ -146,8 +146,10 @@ const char* config_get_input_driver_options(void)
void find_input_driver(void)
{
int i = find_driver_index("input_driver", g_settings.input.driver);
driver_t *driver = driver_get_ptr();
if (i >= 0)
driver.input = (const input_driver_t*)input_driver_find_handle(i);
driver->input = (const input_driver_t*)input_driver_find_handle(i);
else
{
unsigned d;
@ -158,9 +160,9 @@ void find_input_driver(void)
RARCH_LOG_OUTPUT("\t%s\n", input_driver_find_ident(d));
RARCH_WARN("Going to default to first input driver...\n");
driver.input = (const input_driver_t*)input_driver_find_handle(0);
driver->input = (const input_driver_t*)input_driver_find_handle(0);
if (!driver.input)
if (!driver->input)
rarch_fail(1, "find_input_driver()");
}
}
@ -177,8 +179,9 @@ void find_input_driver(void)
bool input_driver_set_rumble_state(unsigned port,
enum retro_rumble_effect effect, uint16_t strength)
{
if (driver.input && driver.input_data && driver.input->set_rumble)
return driver.input->set_rumble(driver.input_data,
driver_t *driver = driver_get_ptr();
if (driver->input && driver->input_data && driver->input->set_rumble)
return driver->input->set_rumble(driver->input_data,
port, effect, strength);
return false;
}
@ -187,21 +190,22 @@ retro_input_t input_driver_keys_pressed(void)
{
int key;
retro_input_t ret = 0;
driver_t *driver = driver_get_ptr();
for (key = 0; key < RARCH_BIND_LIST_END; key++)
{
bool state = false;
if ((!driver.block_libretro_input && (key < RARCH_FIRST_META_KEY)) ||
!driver.block_hotkey)
state = driver.input->key_pressed(driver.input_data, key);
if ((!driver->block_libretro_input && (key < RARCH_FIRST_META_KEY)) ||
!driver->block_hotkey)
state = driver->input->key_pressed(driver->input_data, key);
#ifdef HAVE_OVERLAY
state = state || (driver.overlay_state.buttons & (1ULL << key));
state = state || (driver->overlay_state.buttons & (1ULL << key));
#endif
#ifdef HAVE_COMMAND
if (driver.command)
state = state || rarch_cmd_get(driver.command, key);
if (driver->command)
state = state || rarch_cmd_get(driver->command, key);
#endif
if (state)

9
input/input_overlay.c
View File

@ -751,6 +751,7 @@ input_overlay_t *input_overlay_new(const char *path, bool enable,
float opacity, float scale_factor)
{
input_overlay_t *ol = (input_overlay_t*)calloc(1, sizeof(*ol));
driver_t *driver = driver_get_ptr();
if (!ol)
goto error;
@ -767,15 +768,15 @@ input_overlay_t *input_overlay_new(const char *path, bool enable,
if (!ol->conf)
goto error;
if (!driver.video->overlay_interface)
if (!driver->video->overlay_interface)
{
RARCH_ERR("Overlay interface is not present in video driver.\n");
goto error;
}
if (driver.video && driver.video->overlay_interface)
driver.video->overlay_interface(driver.video_data, &ol->iface);
ol->iface_data = driver.video_data;
if (driver->video && driver->video->overlay_interface)
driver->video->overlay_interface(driver->video_data, &ol->iface);
ol->iface_data = driver->video_data;
if (!ol->iface)
goto error;

16
input/input_sensor.c
View File

@ -29,18 +29,22 @@
bool input_sensor_set_state(unsigned port,
enum retro_sensor_action action, unsigned rate)
{
if (driver.input && driver.input_data &&
driver.input->set_sensor_state)
return driver.input->set_sensor_state(driver.input_data,
driver_t *driver = driver_get_ptr();
if (driver->input && driver->input_data &&
driver->input->set_sensor_state)
return driver->input->set_sensor_state(driver->input_data,
port, action, rate);
return false;
}
float input_sensor_get_input(unsigned port, unsigned id)
{
if (driver.input && driver.input_data &&
driver.input->get_sensor_input)
return driver.input->get_sensor_input(driver.input_data,
driver_t *driver = driver_get_ptr();
if (driver->input && driver->input_data &&
driver->input->get_sensor_input)
return driver->input->get_sensor_input(driver->input_data,
port, id);
return 0.0f;
}

17
input/keyboard_line.c
View File

@ -39,10 +39,11 @@ struct input_keyboard_line
static void input_keyboard_line_toggle_osk(bool enable)
{
driver_t *driver = driver_get_ptr();
if (!g_settings.osk.enable)
return;
driver.keyboard_linefeed_enable = enable;
driver->keyboard_linefeed_enable = enable;
}
/**
@ -179,13 +180,14 @@ static void *g_keyboard_press_data;
const char **input_keyboard_start_line(void *userdata,
input_keyboard_line_complete_t cb)
{
driver_t *driver = driver_get_ptr();
if (g_keyboard_line)
input_keyboard_line_free(g_keyboard_line);
g_keyboard_line = input_keyboard_line_new(userdata, cb);
/* While reading keyboard line input, we have to block all hotkeys. */
driver.block_input = true;
driver->block_input = true;
return input_keyboard_line_get_buffer(g_keyboard_line);
}
@ -200,11 +202,13 @@ const char **input_keyboard_start_line(void *userdata,
**/
void input_keyboard_wait_keys(void *userdata, input_keyboard_press_t cb)
{
driver_t *driver = driver_get_ptr();
g_keyboard_press_cb = cb;
g_keyboard_press_data = userdata;
/* While waiting for input, we have to block all hotkeys. */
driver.block_input = true;
driver->block_input = true;
}
/**
@ -214,9 +218,11 @@ void input_keyboard_wait_keys(void *userdata, input_keyboard_press_t cb)
**/
void input_keyboard_wait_keys_cancel(void)
{
driver_t *driver = driver_get_ptr();
g_keyboard_press_cb = NULL;
g_keyboard_press_data = NULL;
driver.block_input = false;
driver->block_input = false;
}
/**
@ -233,6 +239,7 @@ void input_keyboard_event(bool down, unsigned code,
uint32_t character, uint16_t mod, unsigned device)
{
static bool deferred_wait_keys;
driver_t *driver = driver_get_ptr();
if (deferred_wait_keys)
{
@ -274,7 +281,7 @@ void input_keyboard_event(bool down, unsigned code,
g_keyboard_line = NULL;
/* Unblock all hotkeys. */
driver.block_input = false;
driver->block_input = false;
}
else if (g_extern.system.key_event)
g_extern.system.key_event(down, code, character, mod);

141
libretro_version_1.c
View File

@ -43,6 +43,8 @@ static bool video_frame_scale(const void *data,
unsigned width, unsigned height,
size_t pitch)
{
driver_t *driver = driver_get_ptr();
RARCH_PERFORMANCE_INIT(video_frame_conv);
if (!data)
@ -54,14 +56,14 @@ static bool video_frame_scale(const void *data,
RARCH_PERFORMANCE_START(video_frame_conv);
driver.scaler.in_width = width;
driver.scaler.in_height = height;
driver.scaler.out_width = width;
driver.scaler.out_height = height;
driver.scaler.in_stride = pitch;
driver.scaler.out_stride = width * sizeof(uint16_t);
driver->scaler.in_width = width;
driver->scaler.in_height = height;
driver->scaler.out_width = width;
driver->scaler.out_height = height;
driver->scaler.in_stride = pitch;
driver->scaler.out_stride = width * sizeof(uint16_t);
scaler_ctx_scale(&driver.scaler, driver.scaler_out, data);
scaler_ctx_scale(&driver->scaler, driver->scaler_out, data);
RARCH_PERFORMANCE_STOP(video_frame_conv);
@ -114,8 +116,9 @@ static void video_frame(const void *data, unsigned width,
unsigned output_width = 0, output_height = 0, output_pitch = 0;
const char *msg = NULL;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (!driver.video_active)
if (!driver->video_active)
return;
g_extern.frame_cache.data = data;
@ -125,8 +128,8 @@ static void video_frame(const void *data, unsigned width,
if (video_frame_scale(data, width, height, pitch))
{
data = driver.scaler_out;
pitch = driver.scaler.out_stride;
data = driver->scaler_out;
pitch = driver->scaler.out_stride;
}
/* Slightly messy code,
@ -140,7 +143,7 @@ static void video_frame(const void *data, unsigned width,
recording_dump_frame(data, width, height, pitch);
msg = rarch_main_msg_queue_pull();
driver.current_msg = msg;
driver->current_msg = msg;
if (video_frame_filter(data, width, height, pitch,
&output_width, &output_height, &output_pitch))
@ -151,13 +154,13 @@ static void video_frame(const void *data, unsigned width,
pitch = output_pitch;
}
if (driver.video->frame(driver.video_data, data, width, height, pitch, msg))
if (driver->video->frame(driver->video_data, data, width, height, pitch, msg))
{
runloop->frames.video.count++;
return;
}
driver.video_active = false;
driver->video_active = false;
}
/**
@ -179,20 +182,21 @@ bool retro_flush_audio(const int16_t *data, size_t samples)
struct resampler_data src_data = {0};
struct rarch_dsp_data dsp_data = {0};
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (driver.recording_data)
if (driver->recording_data)
{
struct ffemu_audio_data ffemu_data = {0};
ffemu_data.data = data;
ffemu_data.frames = samples / 2;
if (driver.recording && driver.recording->push_audio)
driver.recording->push_audio(driver.recording_data, &ffemu_data);
if (driver->recording && driver->recording->push_audio)
driver->recording->push_audio(driver->recording_data, &ffemu_data);
}
if (runloop->is_paused || g_settings.audio.mute_enable)
return true;
if (!driver.audio_active || !g_extern.audio_data.data)
if (!driver->audio_active || !g_extern.audio_data.data)
return false;
RARCH_PERFORMANCE_INIT(audio_convert_s16);
@ -232,8 +236,8 @@ bool retro_flush_audio(const int16_t *data, size_t samples)
RARCH_PERFORMANCE_INIT(resampler_proc);
RARCH_PERFORMANCE_START(resampler_proc);
rarch_resampler_process(driver.resampler,
driver.resampler_data, &src_data);
rarch_resampler_process(driver->resampler,
driver->resampler_data, &src_data);
RARCH_PERFORMANCE_STOP(resampler_proc);
output_data = g_extern.audio_data.outsamples;
@ -251,12 +255,12 @@ bool retro_flush_audio(const int16_t *data, size_t samples)
output_size = sizeof(int16_t);
}
if (driver.audio->write(driver.audio_data, output_data,
if (driver->audio->write(driver->audio_data, output_data,
output_frames * output_size * 2) < 0)
{
RARCH_ERR(RETRO_LOG_AUDIO_WRITE_FAILED);
driver.audio_active = false;
driver->audio_active = false;
return false;
}
@ -404,6 +408,7 @@ static int16_t input_state(unsigned port, unsigned device,
g_settings.input.binds[14],
g_settings.input.binds[15],
};
driver_t *driver = driver_get_ptr();
device &= RETRO_DEVICE_MASK;
@ -422,10 +427,10 @@ static int16_t input_state(unsigned port, unsigned device,
id = g_settings.input.remap_ids[port][id];
}
if (!driver.block_libretro_input)
if (!driver->block_libretro_input)
{
if (((id < RARCH_FIRST_META_KEY) || (device == RETRO_DEVICE_KEYBOARD)))
res = driver.input->input_state(driver.input_data, libretro_input_binds, port,
res = driver->input->input_state(driver->input_data, libretro_input_binds, port,
device, idx, id);
#ifdef HAVE_OVERLAY
@ -434,13 +439,13 @@ static int16_t input_state(unsigned port, unsigned device,
switch (device)
{
case RETRO_DEVICE_JOYPAD:
if (driver.overlay_state.buttons & (UINT64_C(1) << id))
if (driver->overlay_state.buttons & (UINT64_C(1) << id))
res |= 1;
break;
case RETRO_DEVICE_KEYBOARD:
if (id < RETROK_LAST)
{
if (OVERLAY_GET_KEY(&driver.overlay_state, id))
if (OVERLAY_GET_KEY(&driver->overlay_state, id))
res |= 1;
}
break;
@ -452,8 +457,8 @@ static int16_t input_state(unsigned port, unsigned device,
base = 2;
if (id == RETRO_DEVICE_ID_ANALOG_Y)
base += 1;
if (driver.overlay_state.analog[base])
res = driver.overlay_state.analog[base];
if (driver->overlay_state.analog[base])
res = driver->overlay_state.analog[base];
}
break;
}
@ -462,7 +467,7 @@ static int16_t input_state(unsigned port, unsigned device,
}
/* flushing_input will be cleared in rarch_main_iterate. */
if (driver.flushing_input)
if (driver->flushing_input)
res = 0;
/* Don't allow turbo for D-pad. */
@ -490,67 +495,68 @@ static INLINE void input_poll_overlay(input_overlay_t *overlay_device, float opa
unsigned i, j, device;
uint16_t key_mod = 0;
bool polled = false;
driver_t *driver = driver_get_ptr();
if (overlay_device->state != OVERLAY_STATUS_ALIVE)
return;
memcpy(old_key_state.keys, driver.overlay_state.keys,
sizeof(driver.overlay_state.keys));
memset(&driver.overlay_state, 0, sizeof(driver.overlay_state));
memcpy(old_key_state.keys, driver->overlay_state.keys,
sizeof(driver->overlay_state.keys));
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state));
device = input_overlay_full_screen(overlay_device) ?
RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER;
for (i = 0;
driver.input->input_state(driver.input_data, NULL, 0, device, i,
driver->input->input_state(driver->input_data, NULL, 0, device, i,
RETRO_DEVICE_ID_POINTER_PRESSED);
i++)
{
input_overlay_state_t polled_data;
int16_t x = driver.input->input_state(driver.input_data, NULL, 0,
int16_t x = driver->input->input_state(driver->input_data, NULL, 0,
device, i, RETRO_DEVICE_ID_POINTER_X);
int16_t y = driver.input->input_state(driver.input_data, NULL, 0,
int16_t y = driver->input->input_state(driver->input_data, NULL, 0,
device, i, RETRO_DEVICE_ID_POINTER_Y);
input_overlay_poll(overlay_device, &polled_data, x, y);
driver.overlay_state.buttons |= polled_data.buttons;
driver->overlay_state.buttons |= polled_data.buttons;
for (j = 0; j < ARRAY_SIZE(driver.overlay_state.keys); j++)
driver.overlay_state.keys[j] |= polled_data.keys[j];
for (j = 0; j < ARRAY_SIZE(driver->overlay_state.keys); j++)
driver->overlay_state.keys[j] |= polled_data.keys[j];
/* Fingers pressed later take prio and matched up
* with overlay poll priorities. */
for (j = 0; j < 4; j++)
if (polled_data.analog[j])
driver.overlay_state.analog[j] = polled_data.analog[j];
driver->overlay_state.analog[j] = polled_data.analog[j];
polled = true;
}
if (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LSHIFT) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RSHIFT))
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LSHIFT) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RSHIFT))
key_mod |= RETROKMOD_SHIFT;
if (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LCTRL) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RCTRL))
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LCTRL) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RCTRL))
key_mod |= RETROKMOD_CTRL;
if (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LALT) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RALT))
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LALT) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RALT))
key_mod |= RETROKMOD_ALT;
if (OVERLAY_GET_KEY(&driver.overlay_state, RETROK_LMETA) ||
OVERLAY_GET_KEY(&driver.overlay_state, RETROK_RMETA))
if (OVERLAY_GET_KEY(&driver->overlay_state, RETROK_LMETA) ||
OVERLAY_GET_KEY(&driver->overlay_state, RETROK_RMETA))
key_mod |= RETROKMOD_META;
/* CAPSLOCK SCROLLOCK NUMLOCK */
for (i = 0; i < ARRAY_SIZE(driver.overlay_state.keys); i++)
for (i = 0; i < ARRAY_SIZE(driver->overlay_state.keys); i++)
{
if (driver.overlay_state.keys[i] != old_key_state.keys[i])
if (driver->overlay_state.keys[i] != old_key_state.keys[i])
{
uint32_t orig_bits = old_key_state.keys[i];
uint32_t new_bits = driver.overlay_state.keys[i];
uint32_t new_bits = driver->overlay_state.keys[i];
for (j = 0; j < 32; j++)
if ((orig_bits & (1 << j)) != (new_bits & (1 << j)))
@ -565,13 +571,13 @@ static INLINE void input_poll_overlay(input_overlay_t *overlay_device, float opa
unsigned bind_plus = RARCH_ANALOG_LEFT_X_PLUS + 2 * j;
unsigned bind_minus = bind_plus + 1;
if (driver.overlay_state.analog[j])
if (driver->overlay_state.analog[j])
continue;
if (driver.overlay_state.buttons & (1ULL << bind_plus))
driver.overlay_state.analog[j] += 0x7fff;
if (driver.overlay_state.buttons & (1ULL << bind_minus))
driver.overlay_state.analog[j] -= 0x7fff;
if (driver->overlay_state.buttons & (1ULL << bind_plus))
driver->overlay_state.analog[j] += 0x7fff;
if (driver->overlay_state.buttons & (1ULL << bind_minus))
driver->overlay_state.analog[j] -= 0x7fff;
}
/* Check for analog_dpad_mode.
@ -587,17 +593,17 @@ static INLINE void input_poll_overlay(input_overlay_t *overlay_device, float opa
if (g_settings.input.analog_dpad_mode[0] == ANALOG_DPAD_LSTICK)
analog_base = 0;
analog_x = (float)driver.overlay_state.analog[analog_base + 0] / 0x7fff;
analog_y = (float)driver.overlay_state.analog[analog_base + 1] / 0x7fff;
analog_x = (float)driver->overlay_state.analog[analog_base + 0] / 0x7fff;
analog_y = (float)driver->overlay_state.analog[analog_base + 1] / 0x7fff;
if (analog_x <= -g_settings.input.axis_threshold)
driver.overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT);
driver->overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT);
if (analog_x >= g_settings.input.axis_threshold)
driver.overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT);
driver->overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT);
if (analog_y <= -g_settings.input.axis_threshold)
driver.overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_UP);
driver->overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_UP);
if (analog_y >= g_settings.input.axis_threshold)
driver.overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN);
driver->overlay_state.buttons |= (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN);
break;
}
@ -619,16 +625,18 @@ static INLINE void input_poll_overlay(input_overlay_t *overlay_device, float opa
**/
static void input_poll(void)
{
driver.input->poll(driver.input_data);
driver_t *driver = driver_get_ptr();
driver->input->poll(driver->input_data);
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_poll_overlay(driver.overlay, g_settings.input.overlay_opacity);
if (driver->overlay)
input_poll_overlay(driver->overlay, g_settings.input.overlay_opacity);
#endif
#ifdef HAVE_COMMAND
if (driver.command)
rarch_cmd_poll(driver.command);
if (driver->command)
rarch_cmd_poll(driver->command);
#endif
}
@ -662,6 +670,7 @@ void retro_set_default_callbacks(void *data)
void retro_init_libretro_cbs(void *data)
{
struct retro_callbacks *cbs = (struct retro_callbacks*)data;
driver_t *driver = driver_get_ptr();
if (!cbs)
return;
@ -675,7 +684,7 @@ void retro_init_libretro_cbs(void *data)
retro_set_default_callbacks(cbs);
#ifdef HAVE_NETPLAY
if (!driver.netplay_data)
if (!driver->netplay_data)
return;
if (g_extern.netplay_is_spectate)

50
location/location_driver.c
View File

@ -112,9 +112,11 @@ const char* config_get_location_driver_options(void)
void find_location_driver(void)
{
driver_t *driver = driver_get_ptr();
int i = find_driver_index("location_driver", g_settings.location.driver);
if (i >= 0)
driver.location = (const location_driver_t*)location_driver_find_handle(i);
driver->location = (const location_driver_t*)location_driver_find_handle(i);
else
{
unsigned d;
@ -126,9 +128,9 @@ void find_location_driver(void)
RARCH_WARN("Going to default to first location driver...\n");
driver.location = (const location_driver_t*)location_driver_find_handle(0);
driver->location = (const location_driver_t*)location_driver_find_handle(0);
if (!driver.location)
if (!driver->location)
rarch_fail(1, "find_location_driver()");
}
}
@ -143,10 +145,11 @@ void find_location_driver(void)
**/
bool driver_location_start(void)
{
if (driver.location && driver.location_data && driver.location->start)
driver_t *driver = driver_get_ptr();
if (driver->location && driver->location_data && driver->location->start)
{
if (g_settings.location.allow)
return driver.location->start(driver.location_data);
return driver->location->start(driver->location_data);
rarch_main_msg_queue_push("Location is explicitly disabled.\n", 1, 180, true);
}
@ -163,8 +166,9 @@ bool driver_location_start(void)
**/
void driver_location_stop(void)
{
if (driver.location && driver.location->stop && driver.location_data)
driver.location->stop(driver.location_data);
driver_t *driver = driver_get_ptr();
if (driver->location && driver->location->stop && driver->location_data)
driver->location->stop(driver->location_data);
}
/**
@ -178,9 +182,10 @@ void driver_location_stop(void)
void driver_location_set_interval(unsigned interval_msecs,
unsigned interval_distance)
{
if (driver.location && driver.location->set_interval
&& driver.location_data)
driver.location->set_interval(driver.location_data,
driver_t *driver = driver_get_ptr();
if (driver->location && driver->location->set_interval
&& driver->location_data)
driver->location->set_interval(driver->location_data,
interval_msecs, interval_distance);
}
@ -200,9 +205,10 @@ void driver_location_set_interval(unsigned interval_msecs,
bool driver_location_get_position(double *lat, double *lon,
double *horiz_accuracy, double *vert_accuracy)
{
if (driver.location && driver.location->get_position
&& driver.location_data)
return driver.location->get_position(driver.location_data,
driver_t *driver = driver_get_ptr();
if (driver->location && driver->location->get_position
&& driver->location_data)
return driver->location->get_position(driver->location_data,
lat, lon, horiz_accuracy, vert_accuracy);
*lat = 0.0;
@ -214,18 +220,19 @@ bool driver_location_get_position(double *lat, double *lon,
void init_location(void)
{
driver_t *driver = driver_get_ptr();
/* Resource leaks will follow if location interface is initialized twice. */
if (driver.location_data)
if (driver->location_data)
return;
find_location_driver();
driver.location_data = driver.location->init();
driver->location_data = driver->location->init();
if (!driver.location_data)
if (!driver->location_data)
{
RARCH_ERR("Failed to initialize location driver. Will continue without location.\n");
driver.location_active = false;
driver->location_active = false;
}
if (g_extern.system.location_callback.initialized)
@ -234,13 +241,14 @@ void init_location(void)
void uninit_location(void)
{
if (driver.location_data && driver.location)
driver_t *driver = driver_get_ptr();
if (driver->location_data && driver->location)
{
if (g_extern.system.location_callback.deinitialized)
g_extern.system.location_callback.deinitialized();
if (driver.location->free)
driver.location->free(driver.location_data);
if (driver->location->free)
driver->location->free(driver->location_data);
}
driver.location_data = NULL;
driver->location_data = NULL;
}

9
menu/drivers/glui.c
View File

@ -71,6 +71,7 @@ static int glui_entry_iterate(unsigned action)
static void glui_blit_line(gl_t *gl, float x, float y, const char *message, uint32_t color)
{
struct font_params params = {0};
driver_t *driver = driver_get_ptr();
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
@ -80,14 +81,14 @@ static void glui_blit_line(gl_t *gl, float x, float y, const char *message, uint
params.color = color;
params.full_screen = true;
if (!driver.video_data)
if (!driver->video_data)
return;
if (!driver.video_poke)
if (!driver->video_poke)
return;
if (!driver.video_poke->set_osd_msg)
if (!driver->video_poke->set_osd_msg)
return;
driver.video_poke->set_osd_msg(driver.video_data,
driver->video_poke->set_osd_msg(driver->video_data,
message, &params, NULL);
}

12
menu/drivers/rgui.c
View File

@ -355,6 +355,7 @@ static void rgui_render(void)
const char *core_version = NULL;
menu_handle_t *menu = menu_driver_resolve();
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (!menu)
return;
@ -502,7 +503,7 @@ static void rgui_render(void)
menu->msg_force = false;
}
else
message_queue = driver.current_msg;
message_queue = driver->current_msg;
rgui_render_messagebox( message_queue);
#endif
@ -583,22 +584,23 @@ static void rgui_set_texture(void)
{
menu_handle_t *menu = menu_driver_resolve();
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (!menu)
return;
if (!driver.video_data)
if (!driver->video_data)
return;
if (!driver.video_poke)
if (!driver->video_poke)
return;
if (!driver.video_poke->set_texture_frame)
if (!driver->video_poke->set_texture_frame)
return;
if (!runloop->frames.video.current.menu.framebuf.dirty)
return;
runloop->frames.video.current.menu.framebuf.dirty = false;
driver.video_poke->set_texture_frame(driver.video_data,
driver->video_poke->set_texture_frame(driver->video_data,
menu->frame_buf.data, false, menu->frame_buf.width, menu->frame_buf.height, 1.0f);
}

4
menu/drivers/shared.h
View File

@ -340,7 +340,9 @@ static INLINE void get_title(const char *label, const char *dir,
snprintf(title, sizeof_title, "AUTOCONFIG DIR %s", dir);
else
{
if (driver.menu->defer_core)
driver_t *driver = driver_get_ptr();
if (driver->menu->defer_core)
snprintf(title, sizeof_title, "CONTENT %s", dir);
else
{

10
menu/drivers/xmb.c
View File

@ -384,6 +384,7 @@ static void xmb_draw_text(gl_t *gl, xmb_handle_t *xmb, const char *str, float x,
{
uint8_t a8 = 0;
struct font_params params = {0};
driver_t *driver = driver_get_ptr();
if (alpha > xmb->alpha)
alpha = xmb->alpha;
@ -407,9 +408,9 @@ static void xmb_draw_text(gl_t *gl, xmb_handle_t *xmb, const char *str, float x,
params.full_screen = true;
params.align_right = align_right;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
if (driver->video_data && driver->video_poke
&& driver->video_poke->set_osd_msg)
driver->video_poke->set_osd_msg(driver->video_data,
str, &params, xmb->font.buf);
}
@ -1504,7 +1505,8 @@ static bool xmb_font_init_first(const gl_font_renderer_t **font_driver,
if (g_settings.video.threaded
&& !g_extern.system.hw_render_callback.context_type)
{
thread_video_t *thr = (thread_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
thread_video_t *thr = (thread_video_t*)driver->video_data;
if (!thr)
return false;

56
menu/menu.c
View File

@ -42,19 +42,20 @@ bool menu_display_update_pending(void)
**/
static void draw_frame(void)
{
if (driver.video_data && driver.video_poke &&
driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data,
driver_t *driver = driver_get_ptr();
if (driver->video_data && driver->video_poke &&
driver->video_poke->set_texture_enable)
driver->video_poke->set_texture_enable(driver->video_data,
true, false);
if (!g_settings.menu.pause_libretro)
{
if (g_extern.main_is_init && !g_extern.libretro_dummy)
{
bool block_libretro_input = driver.block_libretro_input;
driver.block_libretro_input = true;
bool block_libretro_input = driver->block_libretro_input;
driver->block_libretro_input = true;
pretro_run();
driver.block_libretro_input = block_libretro_input;
driver->block_libretro_input = block_libretro_input;
return;
}
}
@ -70,13 +71,15 @@ static void draw_frame(void)
**/
static void menu_update_libretro_info(struct retro_system_info *info)
{
driver_t *driver = driver_get_ptr();
#ifndef HAVE_DYNAMIC
retro_get_system_info(info);
#endif
rarch_main_command(RARCH_CMD_CORE_INFO_INIT);
if (driver.menu_ctx && driver.menu_ctx->context_reset)
driver.menu_ctx->context_reset();
if (driver->menu_ctx && driver->menu_ctx->context_reset)
driver->menu_ctx->context_reset();
rarch_main_command(RARCH_CMD_LOAD_CORE_PERSIST);
}
@ -85,11 +88,12 @@ static void menu_environment_get(int *argc, char *argv[],
void *args, void *params_data)
{
struct rarch_main_wrap *wrap_args = (struct rarch_main_wrap*)params_data;
driver_t *driver = driver_get_ptr();
if (!wrap_args)
return;
wrap_args->no_content = driver.menu->load_no_content;
wrap_args->no_content = driver->menu->load_no_content;
if (!g_extern.has_set_verbosity)
wrap_args->verbose = g_extern.verbosity;
wrap_args->config_path = *g_extern.config_path ? g_extern.config_path : NULL;
@ -132,20 +136,22 @@ static void push_to_history_playlist(void)
**/
bool menu_load_content(void)
{
if (*g_extern.fullpath || (driver.menu && driver.menu->load_no_content))
driver_t *driver = driver_get_ptr();
if (*g_extern.fullpath || (driver->menu && driver->menu->load_no_content))
push_to_history_playlist();
/* redraw menu frame */
if (driver.menu)
driver.menu->msg_force = true;
if (driver->menu)
driver->menu->msg_force = true;
if (driver.menu_ctx && driver.menu_ctx->entry_iterate)
driver.menu_ctx->entry_iterate(MENU_ACTION_NOOP);
if (driver->menu_ctx && driver->menu_ctx->entry_iterate)
driver->menu_ctx->entry_iterate(MENU_ACTION_NOOP);
draw_frame();
if (!(main_load_content(0, NULL, NULL, menu_environment_get,
driver.frontend_ctx->process_args)))
driver->frontend_ctx->process_args)))
{
char name[PATH_MAX_LENGTH], msg[PATH_MAX_LENGTH];
@ -153,15 +159,15 @@ bool menu_load_content(void)
snprintf(msg, sizeof(msg), "Failed to load %s.\n", name);
rarch_main_msg_queue_push(msg, 1, 90, false);
if (driver.menu)
driver.menu->msg_force = true;
if (driver->menu)
driver->menu->msg_force = true;
return false;
}
menu_update_libretro_info(&g_extern.menu.info);
menu_shader_manager_init(driver.menu);
menu_shader_manager_init(driver->menu);
rarch_main_command(RARCH_CMD_HISTORY_INIT);
rarch_main_command(RARCH_CMD_VIDEO_SET_ASPECT_RATIO);
@ -262,6 +268,7 @@ void menu_free_list(void *data)
void menu_free(void *data)
{
menu_handle_t *menu = (menu_handle_t*)data;
driver_t *driver = driver_get_ptr();
if (!menu)
return;
@ -272,8 +279,8 @@ void menu_free(void *data)
menu->shader = NULL;
#endif
if (driver.menu_ctx && driver.menu_ctx->free)
driver.menu_ctx->free(menu);
if (driver->menu_ctx && driver->menu_ctx->free)
driver->menu_ctx->free(menu);
#ifdef HAVE_LIBRETRODB
menu_database_free(menu);
@ -392,6 +399,7 @@ int menu_iterate(retro_input_t input,
runloop_t *runloop = rarch_main_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
menu->cur_time = rarch_get_time_usec();
menu->dt = menu->cur_time - menu->old_time;
@ -407,14 +415,14 @@ int menu_iterate(retro_input_t input,
last_clock_update = menu->cur_time;
}
if (driver.menu_ctx && driver.menu_ctx->entry_iterate)
ret = driver.menu_ctx->entry_iterate(action);
if (driver->menu_ctx && driver->menu_ctx->entry_iterate)
ret = driver->menu_ctx->entry_iterate(action);
if (runloop->is_menu && !runloop->is_idle)
draw_frame();
if (driver.menu_ctx && driver.menu_ctx->set_texture)
driver.menu_ctx->set_texture();
if (driver->menu_ctx && driver->menu_ctx->set_texture)
driver->menu_ctx->set_texture();
if (ret)
return -1;

20
menu/menu_driver.c
View File

@ -123,9 +123,11 @@ const char* config_get_menu_driver_options(void)
void find_menu_driver(void)
{
driver_t *driver = driver_get_ptr();
int i = find_driver_index("menu_driver", g_settings.menu.driver);
if (i >= 0)
driver.menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(i);
driver->menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(i);
else
{
unsigned d;
@ -136,26 +138,27 @@ void find_menu_driver(void)
RARCH_LOG_OUTPUT("\t%s\n", menu_driver_find_ident(d));
RARCH_WARN("Going to default to first menu driver...\n");
driver.menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(0);
driver->menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(0);
if (!driver.menu_ctx)
if (!driver->menu_ctx)
rarch_fail(1, "find_menu_driver()");
}
}
void init_menu(void)
{
if (driver.menu)
driver_t *driver = driver_get_ptr();
if (driver->menu)
return;
find_menu_driver();
if (!(driver.menu = (menu_handle_t*)menu_init(driver.menu_ctx)))
if (!(driver->menu = (menu_handle_t*)menu_init(driver->menu_ctx)))
{
RARCH_ERR("Cannot initialize menu.\n");
rarch_fail(1, "init_menu()");
}
if (!(menu_entries_init(driver.menu)))
if (!(menu_entries_init(driver->menu)))
{
RARCH_ERR("Cannot initialize menu lists.\n");
rarch_fail(1, "init_menu()");
@ -164,7 +167,8 @@ void init_menu(void)
menu_handle_t *menu_driver_resolve(void)
{
if (!driver.menu)
driver_t *driver = driver_get_ptr();
if (!driver->menu)
return NULL;
return driver.menu;
return driver->menu;
}

24
menu/menu_entries.c
View File

@ -87,6 +87,7 @@ int menu_entries_push_list(menu_handle_t *menu,
unsigned type, unsigned setting_flags)
{
rarch_setting_t *setting = NULL;
driver_t *driver = driver_get_ptr();
settings_list_free(menu->list_settings);
menu->list_settings = (rarch_setting_t *)setting_data_new(setting_flags);
@ -110,8 +111,8 @@ int menu_entries_push_list(menu_handle_t *menu,
setting->name, menu_entries_setting_set_flags(setting), 0);
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -332,9 +333,11 @@ int menu_entries_parse_list(
if (!*dir)
{
driver_t *driver = driver_get_ptr();
menu_entries_parse_drive_list(list);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(dir, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(dir, label, type);
return 0;
}
#if defined(GEKKO) && defined(HW_RVL)
@ -442,7 +445,9 @@ int menu_entries_parse_list(
if (!strcmp(label, "core_list"))
{
menu_list_get_last_stack(driver.menu->menu_list, &dir, NULL, NULL);
driver_t *driver = driver_get_ptr();
menu_list_get_last_stack(driver->menu->menu_list, &dir, NULL, NULL);
list_size = file_list_get_size(list);
for (i = 0; i < list_size; i++)
@ -476,17 +481,18 @@ int menu_entries_deferred_push(file_list_t *list, file_list_t *menu_list)
const char *path = NULL;
const char *label = NULL;
menu_file_list_cbs_t *cbs = NULL;
driver_t *driver = driver_get_ptr();
menu_list_get_last_stack(driver.menu->menu_list, &path, &label, &type);
menu_list_get_last_stack(driver->menu->menu_list, &path, &label, &type);
if (!strcmp(label, "Main Menu"))
return menu_entries_push_list(driver.menu, list, path, label, type,
return menu_entries_push_list(driver->menu, list, path, label, type,
SL_FLAG_MAIN_MENU);
else if (!strcmp(label, "Horizontal Menu"))
return menu_entries_push_horizontal_menu_list(driver.menu, list, path, label, type);
return menu_entries_push_horizontal_menu_list(driver->menu, list, path, label, type);
cbs = (menu_file_list_cbs_t*)
menu_list_get_last_stack_actiondata(driver.menu->menu_list);
menu_list_get_last_stack_actiondata(driver->menu->menu_list);
if (!cbs->action_deferred_push)
return 0;

80
menu/menu_entries_cbs_deferred_push.c
View File

@ -133,6 +133,7 @@ static int deferred_push_core_information(void *data, void *userdata,
core_info_t *info = NULL;
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -263,8 +264,8 @@ static int deferred_push_core_information(void *data, void *userdata,
"No information available.", "",
MENU_SETTINGS_CORE_OPTION_NONE, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -283,6 +284,7 @@ static int deferred_push_rdb_entry_detail(void *data, void *userdata,
file_list_t *menu_list = NULL;
struct string_list *str_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -539,8 +541,8 @@ static int deferred_push_rdb_entry_detail(void *data, void *userdata,
"No information available.", "",
0, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path,
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path,
str_list->elems[0].data, type);
ret = 0;
@ -774,6 +776,7 @@ static int deferred_push_core_information(void *data, void *userdata,
core_info_t *info = NULL;
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -904,8 +907,8 @@ static int deferred_push_core_information(void *data, void *userdata,
"No information available.", "",
MENU_SETTINGS_CORE_OPTION_NONE, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -916,6 +919,7 @@ static int deferred_push_performance_counters(void *data, void *userdata,
{
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -926,8 +930,8 @@ static int deferred_push_performance_counters(void *data, void *userdata,
menu_list_push(list, "Core Counters", "core_counters",
MENU_SETTING_ACTION, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -939,6 +943,7 @@ static int deferred_push_video_shader_parameters_common(void *data, void *userda
unsigned i;
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -952,8 +957,8 @@ static int deferred_push_video_shader_parameters_common(void *data, void *userda
base_parameter + i, 0);
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -995,6 +1000,7 @@ static int deferred_push_settings(void *data, void *userdata,
file_list_t *list = NULL;
file_list_t *menu_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -1048,8 +1054,8 @@ static int deferred_push_settings(void *data, void *userdata,
}
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1063,6 +1069,7 @@ static int deferred_push_settings_subgroup(void *data, void *userdata,
file_list_t *list = NULL;
file_list_t *menu_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -1122,8 +1129,8 @@ static int deferred_push_settings_subgroup(void *data, void *userdata,
group_label, menu_entries_setting_set_flags(setting), 0);
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1145,6 +1152,7 @@ static int deferred_push_video_options(void *data, void *userdata,
file_list_t *list = NULL;
file_list_t *menu_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -1167,8 +1175,8 @@ static int deferred_push_video_options(void *data, void *userdata,
0, 0);
#endif
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1181,6 +1189,7 @@ static int deferred_push_shader_options(void *data, void *userdata,
file_list_t *list = NULL;
file_list_t *menu_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -1227,8 +1236,8 @@ static int deferred_push_shader_options(void *data, void *userdata,
MENU_SETTINGS_SHADER_PASS_SCALE_0 + i, 0);
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1238,6 +1247,7 @@ static int deferred_push_options(void *data, void *userdata,
{
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -1263,8 +1273,8 @@ static int deferred_push_options(void *data, void *userdata,
MENU_SETTING_ACTION, 0);
#endif
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1274,6 +1284,7 @@ static int deferred_push_management_options(void *data, void *userdata,
{
file_list_t *list = (file_list_t*)data;
file_list_t *menu_list = (file_list_t*)userdata;
driver_t *driver = driver_get_ptr();
if (!list || !menu_list)
return -1;
@ -1287,8 +1298,8 @@ static int deferred_push_management_options(void *data, void *userdata,
MENU_SETTING_ACTION, 0);
#endif
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1319,6 +1330,7 @@ static int push_perfcounter_generic(
file_list_t *list = NULL;
file_list_t *menu_list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -1332,8 +1344,8 @@ static int push_perfcounter_generic(
menu_list_clear(list);
push_perfcounter(menu, list, counters, num, ident);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1360,6 +1372,7 @@ static int deferred_push_core_cheat_options(void *data, void *userdata,
unsigned i;
file_list_t *list = (file_list_t*)data;
cheat_manager_t *cheat = g_extern.cheat;
driver_t *driver = driver_get_ptr();
(void)userdata;
(void)type;
@ -1395,8 +1408,8 @@ static int deferred_push_core_cheat_options(void *data, void *userdata,
menu_list_push(list, cheat_label, "", MENU_SETTINGS_CHEAT_BEGIN + i, 0);
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1406,6 +1419,7 @@ static int deferred_push_core_input_remapping_options(void *data, void *userdata
{
unsigned p, retro_id;
file_list_t *list = (file_list_t*)data;
driver_t *driver = driver_get_ptr();
(void)userdata;
(void)type;
@ -1438,8 +1452,8 @@ static int deferred_push_core_input_remapping_options(void *data, void *userdata
}
}
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1449,6 +1463,7 @@ static int deferred_push_core_options(void *data, void *userdata,
{
unsigned i;
file_list_t *list = (file_list_t*)data;
driver_t *driver = driver_get_ptr();
(void)userdata;
@ -1470,8 +1485,8 @@ static int deferred_push_core_options(void *data, void *userdata,
menu_list_push(list, "No options available.", "",
MENU_SETTINGS_CORE_OPTION_NONE, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}
@ -1480,6 +1495,7 @@ static int deferred_push_disk_options(void *data, void *userdata,
const char *path, const char *label, unsigned type)
{
file_list_t *list = (file_list_t*)data;
driver_t *driver = driver_get_ptr();
(void)userdata;
@ -1494,8 +1510,8 @@ static int deferred_push_disk_options(void *data, void *userdata,
menu_list_push(list, "Disk Image Append", "disk_image_append",
MENU_SETTINGS_CORE_DISK_OPTIONS_DISK_IMAGE_APPEND, 0);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}

80
menu/menu_entries_cbs_iterate.c
View File

@ -111,6 +111,7 @@ static int load_or_open_zip_iterate(unsigned action)
{
char msg[PATH_MAX_LENGTH];
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -121,11 +122,11 @@ static int load_or_open_zip_iterate(unsigned action)
" - OK to open as Folder\n"
" - Cancel/Back to Load \n");
if (driver.video_data && driver.menu_ctx
&& driver.menu_ctx->render_messagebox)
if (driver->video_data && driver->menu_ctx
&& driver->menu_ctx->render_messagebox)
{
if (*msg && msg[0] != '\0')
driver.menu_ctx->render_messagebox(msg);
driver->menu_ctx->render_messagebox(msg);
}
switch (action)
@ -174,10 +175,11 @@ static int mouse_post_iterate(menu_file_list_cbs_t *cbs, const char *path,
{
if (!menu->mouse.oldleft)
{
driver_t *driver = driver_get_ptr();
rarch_setting_t *setting =
(rarch_setting_t*)setting_data_find_setting
(driver.menu->list_settings,
driver.menu->menu_list->selection_buf->list[menu->navigation.selection_ptr].label);
(driver->menu->list_settings,
driver->menu->menu_list->selection_buf->list[menu->navigation.selection_ptr].label);
menu->mouse.oldleft = true;
#if 0
@ -240,11 +242,13 @@ static int action_iterate_help(const char *label, unsigned action)
char desc[ARRAY_SIZE(binds)][64];
char msg[PATH_MAX_LENGTH];
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return 0;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx && driver->menu_ctx->render)
driver->menu_ctx->render();
for (i = 0; i < ARRAY_SIZE(binds); i++)
{
@ -281,8 +285,8 @@ static int action_iterate_help(const char *label, unsigned action)
"Press Accept/OK to continue.",
desc[0], desc[1], desc[2], desc[3], desc[4], desc[5], desc[6], desc[7]);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(msg);
if (driver->video_data && driver->menu_ctx && driver->menu_ctx->render_messagebox)
driver->menu_ctx->render_messagebox(msg);
if (action == MENU_ACTION_OK)
menu_list_pop(menu->menu_list->menu_stack, NULL);
@ -298,13 +302,14 @@ static int action_iterate_info(const char *label, unsigned action)
rarch_setting_t *current_setting = NULL;
file_list_t *list = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return 0;
list = (file_list_t*)menu->menu_list->selection_buf;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx && driver->menu_ctx->render)
driver->menu_ctx->render();
current_setting = (rarch_setting_t*)setting_data_find_setting(
menu->list_settings,
@ -332,11 +337,11 @@ static int action_iterate_info(const char *label, unsigned action)
setting_data_get_description(needle, msg, sizeof(msg));
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render_messagebox)
if (driver->video_data && driver->menu_ctx &&
driver->menu_ctx->render_messagebox)
{
if (*msg && msg[0] != '\0')
driver.menu_ctx->render_messagebox(msg);
driver->menu_ctx->render_messagebox(msg);
}
if (action == MENU_ACTION_OK)
@ -371,6 +376,7 @@ static int action_iterate_menu_viewport(const char *label, unsigned action)
unsigned type = 0;
video_viewport_t *custom = &g_extern.console.screen.viewports.custom_vp;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -463,9 +469,9 @@ static int action_iterate_menu_viewport(const char *label, unsigned action)
{
video_viewport_t vp;
if (driver.video_data && driver.video &&
driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (driver->video_data && driver->video &&
driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
if (type == MENU_SETTINGS_CUSTOM_VIEWPORT)
{
@ -494,8 +500,8 @@ static int action_iterate_menu_viewport(const char *label, unsigned action)
menu_list_get_last_stack(menu->menu_list, NULL, &label, &type);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx && driver->menu_ctx->render)
driver->menu_ctx->render();
if (g_settings.video.scale_integer)
{
@ -524,9 +530,9 @@ static int action_iterate_menu_viewport(const char *label, unsigned action)
base_msg, custom->x, custom->y, custom->width, custom->height);
}
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(msg);
if (driver->video_data && driver->menu_ctx &&
driver->menu_ctx->render_messagebox)
driver->menu_ctx->render_messagebox(msg);
if (!custom->width)
custom->width = stride_x;
@ -564,12 +570,14 @@ static int action_iterate_custom_bind_keyboard(const char *label, unsigned actio
static int action_iterate_message(const char *label, unsigned action)
{
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
if (driver.video_data && driver.menu_ctx
&& driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(menu->message_contents);
if (driver->video_data && driver->menu_ctx
&& driver->menu_ctx->render_messagebox)
driver->menu_ctx->render_messagebox(menu->message_contents);
if (action == MENU_ACTION_OK)
menu_list_pop_stack(menu->menu_list);
@ -582,6 +590,7 @@ static int mouse_iterate(unsigned *action)
const struct retro_keybind *binds[MAX_USERS];
menu_handle_t *menu = menu_driver_resolve();
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -616,21 +625,21 @@ static int mouse_iterate(unsigned *action)
return 0;
}
menu->mouse.left = driver.input->input_state(driver.input_data,
menu->mouse.left = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT);
menu->mouse.right = driver.input->input_state(driver.input_data,
menu->mouse.right = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT);
menu->mouse.wheelup = driver.input->input_state(driver.input_data,
menu->mouse.wheelup = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_WHEELUP);
menu->mouse.wheeldown = driver.input->input_state(driver.input_data,
menu->mouse.wheeldown = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_WHEELDOWN);
menu->mouse.hwheelup = driver.input->input_state(driver.input_data,
menu->mouse.hwheelup = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELUP);
menu->mouse.hwheeldown = driver.input->input_state(driver.input_data,
menu->mouse.hwheeldown = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELDOWN);
menu->mouse.dx = driver.input->input_state(driver.input_data,
menu->mouse.dx = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_X);
menu->mouse.dy = driver.input->input_state(driver.input_data,
menu->mouse.dy = driver->input->input_state(driver->input_data,
binds, 0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_Y);
menu->mouse.x += menu->mouse.dx;
@ -665,6 +674,7 @@ static int action_iterate_main(const char *label, unsigned action)
const char *path_offset = NULL;
menu_file_list_cbs_t *cbs = NULL;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return 0;
@ -774,8 +784,8 @@ static int action_iterate_main(const char *label, unsigned action)
ret = mouse_post_iterate(cbs, path_offset, label_offset, type_offset, action);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx && driver->menu_ctx->render)
driver->menu_ctx->render();
/* Have to defer it so we let settings refresh. */
if (menu->push_start_screen)

25
menu/menu_entries_cbs_ok.c
View File

@ -262,10 +262,11 @@ static int action_ok_core_updater_list(const char *path,
{
char url_path[PATH_MAX_LENGTH];
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
driver.menu->nonblocking_refresh = true;
driver->menu->nonblocking_refresh = true;
(void)url_path;
#ifdef HAVE_NETWORKING
@ -835,6 +836,7 @@ static int action_ok_custom_viewport(const char *path,
/* Start with something sane. */
video_viewport_t *custom = &g_extern.console.screen.viewports.custom_vp;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -847,9 +849,9 @@ static int action_ok_custom_viewport(const char *path,
MENU_SETTINGS_CUSTOM_VIEWPORT,
idx);
if (driver.video_data && driver.video &&
driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, custom);
if (driver->video_data && driver->video &&
driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, custom);
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
(float)custom->width / custom->height;
@ -1064,6 +1066,7 @@ static int action_ok_help(const char *path,
static int action_ok_video_resolution(const char *path,
const char *label, unsigned type, size_t idx)
{
#ifdef __CELLOS_LV2__
if (g_extern.console.screen.resolutions.list[
g_extern.console.screen.resolutions.current.idx] ==
@ -1080,16 +1083,18 @@ static int action_ok_video_resolution(const char *path,
rarch_main_command(RARCH_CMD_REINIT);
#else
if (driver.video_data && driver.video_poke &&
driver.video_poke->get_video_output_size)
driver_t *driver = driver_get_ptr();
if (driver->video_data && driver->video_poke &&
driver->video_poke->get_video_output_size)
{
unsigned width = 0, height = 0;
driver.video_poke->get_video_output_size(driver.video_data,
driver->video_poke->get_video_output_size(driver->video_data,
&width, &height);
if (driver.video_data && driver.video_poke &&
driver.video_poke->set_video_mode)
driver.video_poke->set_video_mode(driver.video_data,
if (driver->video_data && driver->video_poke &&
driver->video_poke->set_video_mode)
driver->video_poke->set_video_mode(driver->video_data,
width, height, true);
}
#endif

13
menu/menu_entries_cbs_representation.c
View File

@ -207,10 +207,11 @@ static void menu_action_setting_disp_set_label_shader_parameter(
const struct video_shader_parameter *param = NULL;
struct video_shader *shader = NULL;
#endif
driver_t *driver = driver_get_ptr();
if (!driver.video_poke)
if (!driver->video_poke)
return;
if (!driver.video_data)
if (!driver->video_data)
return;
*type_str = '\0';
@ -493,6 +494,8 @@ static void menu_action_setting_disp_set_label_menu_video_resolution(
char *path_buf, size_t path_buf_size)
{
unsigned width = 0, height = 0;
driver_t *driver = driver_get_ptr();
*w = 19;
*type_str = '\0';
@ -501,10 +504,10 @@ static void menu_action_setting_disp_set_label_menu_video_resolution(
strlcpy(path_buf, path, path_buf_size);
if (driver.video_data && driver.video_poke &&
driver.video_poke->get_video_output_size)
if (driver->video_data && driver->video_poke &&
driver->video_poke->get_video_output_size)
{
driver.video_poke->get_video_output_size(driver.video_data,
driver->video_poke->get_video_output_size(driver->video_data,
&width, &height);
snprintf(type_str, type_str_size, "%ux%u", width, height);
}

22
menu/menu_entries_cbs_toggle.c
View File

@ -201,13 +201,15 @@ static int action_toggle_mainmenu(unsigned type, const char *label,
{
menu_file_list_cbs_t *cbs = NULL;
unsigned push_list = 0;
driver_t *driver = driver_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
if (!menu)
return -1;
if (file_list_get_size(menu->menu_list->menu_stack) == 1)
{
if (!strcmp(driver.menu_ctx->ident, "xmb"))
if (!strcmp(driver->menu_ctx->ident, "xmb"))
{
menu->navigation.selection_ptr = 0;
switch (action)
@ -235,8 +237,8 @@ static int action_toggle_mainmenu(unsigned type, const char *label,
switch (push_list)
{
case 1:
if (driver.menu_ctx->list_cache)
driver.menu_ctx->list_cache(true, action);
if (driver->menu_ctx->list_cache)
driver->menu_ctx->list_cache(true, action);
if (cbs && cbs->action_content_list_switch)
return cbs->action_content_list_switch(
@ -409,6 +411,8 @@ static int action_toggle_shader_num_passes(unsigned type, const char *label,
static int action_toggle_video_resolution(unsigned type, const char *label,
unsigned action, bool wraparound)
{
driver_t *driver = driver_get_ptr();
#if defined(__CELLOS_LV2__)
switch (action)
{
@ -436,17 +440,17 @@ static int action_toggle_video_resolution(unsigned type, const char *label,
switch (action)
{
case MENU_ACTION_LEFT:
if (driver.video_data && driver.video_poke &&
driver.video_poke->get_video_output_prev)
if (driver->video_data && driver->video_poke &&
driver->video_poke->get_video_output_prev)
{
driver.video_poke->get_video_output_prev(driver.video_data);
driver->video_poke->get_video_output_prev(driver->video_data);
}
break;
case MENU_ACTION_RIGHT:
if (driver.video_data && driver.video_poke &&
driver.video_poke->get_video_output_next)
if (driver->video_data && driver->video_poke &&
driver->video_poke->get_video_output_next)
{
driver.video_poke->get_video_output_next(driver.video_data);
driver->video_poke->get_video_output_next(driver->video_data);
}
break;
}

57
menu/menu_input.c
View File

@ -51,6 +51,7 @@ void menu_input_key_start_line(const char *label,
static void menu_input_key_end_line(void)
{
driver_t *driver = driver_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
if (!menu)
return;
@ -60,7 +61,7 @@ static void menu_input_key_end_line(void)
menu->keyboard.label_setting = NULL;
/* Avoid triggering states on pressing return. */
driver.flushing_input = true;
driver->flushing_input = true;
}
static void menu_input_search_callback(void *userdata, const char *str)
@ -169,6 +170,7 @@ void menu_input_st_cheat_callback(void *userdata, const char *str)
void menu_input_search_start(void)
{
driver_t *driver = driver_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
if (!menu)
return;
@ -176,7 +178,7 @@ void menu_input_search_start(void)
menu->keyboard.display = true;
menu->keyboard.label = "Search: ";
menu->keyboard.buffer =
input_keyboard_start_line(driver.menu, menu_input_search_callback);
input_keyboard_start_line(driver->menu, menu_input_search_callback);
}
void menu_input_key_event(bool down, unsigned keycode,
@ -194,16 +196,17 @@ void menu_input_poll_bind_state(struct menu_bind_state *state)
{
unsigned i, b, a, h;
const rarch_joypad_driver_t *joypad = NULL;
driver_t *driver = driver_get_ptr();
if (!state)
return;
memset(state->state, 0, sizeof(state->state));
state->skip = driver.input->input_state(driver.input_data, NULL, 0,
state->skip = driver->input->input_state(driver->input_data, NULL, 0,
RETRO_DEVICE_KEYBOARD, 0, RETROK_RETURN);
if (driver.input && driver.input_data && driver.input->get_joypad_driver)
joypad = driver.input->get_joypad_driver(driver.input_data);
if (driver->input && driver->input_data && driver->input->get_joypad_driver)
joypad = driver->input->get_joypad_driver(driver->input_data);
if (!joypad)
{
@ -240,12 +243,13 @@ void menu_input_poll_bind_get_rested_axes(struct menu_bind_state *state)
{
unsigned i, a;
const rarch_joypad_driver_t *joypad = NULL;
driver_t *driver = driver_get_ptr();
if (!state)
return;
if (driver.input && driver.input_data && driver.input->get_joypad_driver)
joypad = driver.input->get_joypad_driver(driver.input_data);
if (driver->input && driver->input_data && driver->input->get_joypad_driver)
joypad = driver->input->get_joypad_driver(driver->input_data);
if (!joypad)
{
@ -373,34 +377,35 @@ int menu_input_bind_iterate(void)
char msg[PATH_MAX_LENGTH];
struct menu_bind_state binds;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return 1;
binds = menu->binds;
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx &&
driver->menu_ctx->render)
driver->menu_ctx->render();
snprintf(msg, sizeof(msg), "[%s]\npress joypad\n(RETURN to skip)",
input_config_bind_map[
menu->binds.begin - MENU_SETTINGS_BIND_BEGIN].desc);
if (driver.video_data && driver.menu_ctx
&& driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox( msg);
if (driver->video_data && driver->menu_ctx
&& driver->menu_ctx->render_messagebox)
driver->menu_ctx->render_messagebox( msg);
driver.block_input = true;
driver->block_input = true;
menu_input_poll_bind_state(&binds);
if ((binds.skip && !menu->binds.skip) ||
menu_input_poll_find_trigger(&menu->binds, &binds))
{
driver.block_input = false;
driver->block_input = false;
/* Avoid new binds triggering things right away. */
driver.flushing_input = true;
driver->flushing_input = true;
binds.begin++;
@ -421,13 +426,14 @@ int menu_input_bind_iterate_keyboard(void)
int timeout = 0;
bool timed_out = false;
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render)
driver.menu_ctx->render();
if (driver->video_data && driver->menu_ctx &&
driver->menu_ctx->render)
driver->menu_ctx->render();
current = rarch_get_time_usec();
timeout = (menu->binds.timeout_end - current) / 1000000;
@ -436,9 +442,9 @@ int menu_input_bind_iterate_keyboard(void)
menu->binds.begin - MENU_SETTINGS_BIND_BEGIN].desc,
timeout);
if (driver.video_data && driver.menu_ctx
&& driver.menu_ctx->render_messagebox)
driver.menu_ctx->render_messagebox(msg);
if (driver->video_data && driver->menu_ctx
&& driver->menu_ctx->render_messagebox)
driver->menu_ctx->render_messagebox(msg);
if (timeout <= 0)
{
@ -457,7 +463,7 @@ int menu_input_bind_iterate_keyboard(void)
if (menu->binds.begin > menu->binds.last)
{
/* Avoid new binds triggering things right away. */
driver.flushing_input = true;
driver->flushing_input = true;
/* We won't be getting any key events, so just cancel early. */
if (timed_out)
@ -481,11 +487,12 @@ unsigned menu_input_frame(retro_input_t input, retro_input_t trigger_input)
| (1ULL << RETRO_DEVICE_ID_JOYPAD_L)
| (1ULL << RETRO_DEVICE_ID_JOYPAD_R);
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return 0;
driver.retro_ctx.poll_cb();
driver->retro_ctx.poll_cb();
/* don't run anything first frame, only capture held inputs
* for old_input_state. */
@ -518,7 +525,7 @@ unsigned menu_input_frame(retro_input_t input, retro_input_t trigger_input)
menu->delay.count += menu->dt / IDEAL_DT;
if (driver.block_input)
if (driver->block_input)
trigger_input = 0;
if (trigger_input & (1ULL << RETRO_DEVICE_ID_JOYPAD_UP))
return MENU_ACTION_UP;

49
menu/menu_list.c
View File

@ -139,17 +139,18 @@ static void menu_entries_build_scroll_indices(file_list_t *list)
static void menu_list_destroy(file_list_t *list)
{
unsigned i;
driver_t *driver = driver_get_ptr();
if (!list)
return;
if (!driver.menu_ctx)
if (!driver->menu_ctx)
goto end;
for (i = 0; i < list->size; i++)
{
if (driver.menu_ctx->list_delete)
driver.menu_ctx->list_delete(list, i, list->size);
if (driver->menu_ctx->list_delete)
driver->menu_ctx->list_delete(list, i, list->size);
menu_common_list_delete(list, i, list->size);
}
@ -279,14 +280,15 @@ void menu_list_flush_stack_by_needle(menu_list_t *list,
void menu_list_pop_stack(menu_list_t *list)
{
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu || !list)
return;
if (file_list_get_size(list->menu_stack) <= 1)
return;
if (driver.menu_ctx->list_cache)
driver.menu_ctx->list_cache(false, 0);
if (driver->menu_ctx->list_cache)
driver->menu_ctx->list_cache(false, 0);
menu_list_pop(list->menu_stack, &menu->navigation.selection_ptr);
menu->need_refresh = true;
@ -315,37 +317,39 @@ void menu_list_pop_stack_by_needle(menu_list_t *list,
void menu_list_pop(file_list_t *list, size_t *directory_ptr)
{
if (!driver.menu_ctx)
driver_t *driver = driver_get_ptr();
if (!driver->menu_ctx)
goto end;
if (list->size != 0)
{
size_t list_size = list->size - 1;
if (driver.menu_ctx->list_delete)
driver.menu_ctx->list_delete(list, list_size, list_size);
if (driver->menu_ctx->list_delete)
driver->menu_ctx->list_delete(list, list_size, list_size);
menu_common_list_delete(list, list_size, list_size);
}
end:
file_list_pop(list, directory_ptr);
if (!driver.menu_ctx)
if (!driver->menu_ctx)
return;
if (driver.menu_ctx->list_set_selection)
driver.menu_ctx->list_set_selection(list);
if (driver->menu_ctx->list_set_selection)
driver->menu_ctx->list_set_selection(list);
menu_common_list_set_selection(list);
}
void menu_list_clear(file_list_t *list)
{
if (!driver.menu_ctx)
driver_t *driver = driver_get_ptr();
if (!driver->menu_ctx)
goto end;
if (driver.menu_ctx->list_clear)
driver.menu_ctx->list_clear(list);
if (driver->menu_ctx->list_clear)
driver->menu_ctx->list_clear(list);
end:
menu_common_list_clear(list);
@ -355,11 +359,12 @@ static void menu_list_insert(file_list_t *list,
const char *path, const char *label,
unsigned type, size_t directory_ptr)
{
if (!driver.menu_ctx)
driver_t *driver = driver_get_ptr();
if (!driver->menu_ctx)
return;
if (driver.menu_ctx->list_insert)
driver.menu_ctx->list_insert(list, path, label, list->size - 1);
if (driver->menu_ctx->list_insert)
driver->menu_ctx->list_insert(list, path, label, list->size - 1);
menu_common_list_insert(list, path, label, type, list->size - 1);
}
@ -399,13 +404,14 @@ int menu_list_push_stack_refresh(menu_list_t *list, const char *path, const char
unsigned type, size_t directory_ptr)
{
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
if (!list)
return -1;
if (driver.menu_ctx->list_cache)
driver.menu_ctx->list_cache(false, 0);
if (driver->menu_ctx->list_cache)
driver->menu_ctx->list_cache(false, 0);
menu_list_push_stack(list, path, label, type, directory_ptr);
menu_navigation_clear(&menu->navigation, true);
@ -435,6 +441,7 @@ int menu_list_populate_generic(file_list_t *list, const char *path,
const char *label, unsigned type)
{
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
if (!menu)
return -1;
@ -444,8 +451,8 @@ int menu_list_populate_generic(file_list_t *list, const char *path,
menu_entries_build_scroll_indices(list);
menu_entries_refresh(list);
if (driver.menu_ctx && driver.menu_ctx->populate_entries)
driver.menu_ctx->populate_entries(path, label, type);
if (driver->menu_ctx && driver->menu_ctx->populate_entries)
driver->menu_ctx->populate_entries(path, label, type);
return 0;
}

42
menu/menu_navigation.c
View File

@ -30,13 +30,14 @@
**/
void menu_navigation_clear(menu_navigation_t *nav, bool pending_push)
{
driver_t *driver = driver_get_ptr();
if (!nav)
return;
nav->selection_ptr = 0;
if (driver.menu_ctx && driver.menu_ctx->navigation_clear)
driver.menu_ctx->navigation_clear(pending_push);
if (driver->menu_ctx && driver->menu_ctx->navigation_clear)
driver->menu_ctx->navigation_clear(pending_push);
}
/**
@ -46,6 +47,8 @@ void menu_navigation_clear(menu_navigation_t *nav, bool pending_push)
**/
void menu_navigation_decrement(menu_navigation_t *nav, unsigned scroll_speed)
{
driver_t *driver = driver_get_ptr();
if (!nav)
return;
@ -56,13 +59,13 @@ void menu_navigation_decrement(menu_navigation_t *nav, unsigned scroll_speed)
{
if (g_settings.menu.navigation.wraparound.vertical_enable)
menu_navigation_set(nav,
menu_list_get_size(driver.menu->menu_list) - 1, true);
menu_list_get_size(driver->menu->menu_list) - 1, true);
else
menu_navigation_set(nav, 0, true);
}
if (driver.menu_ctx && driver.menu_ctx->navigation_decrement)
driver.menu_ctx->navigation_decrement();
if (driver->menu_ctx && driver->menu_ctx->navigation_decrement)
driver->menu_ctx->navigation_decrement();
}
/**
@ -72,10 +75,11 @@ void menu_navigation_decrement(menu_navigation_t *nav, unsigned scroll_speed)
**/
void menu_navigation_increment(menu_navigation_t *nav, unsigned scroll_speed)
{
driver_t *driver = driver_get_ptr();
if (!nav)
return;
if (nav->selection_ptr + scroll_speed < (menu_list_get_size(driver.menu->menu_list)))
if (nav->selection_ptr + scroll_speed < (menu_list_get_size(driver->menu->menu_list)))
menu_navigation_set(nav,
nav->selection_ptr + scroll_speed, true);
else
@ -84,11 +88,11 @@ void menu_navigation_increment(menu_navigation_t *nav, unsigned scroll_speed)
menu_navigation_clear(nav, false);
else
menu_navigation_set(nav,
menu_list_get_size(driver.menu->menu_list) - 1, true);
menu_list_get_size(driver->menu->menu_list) - 1, true);
}
if (driver.menu_ctx && driver.menu_ctx->navigation_increment)
driver.menu_ctx->navigation_increment();
if (driver->menu_ctx && driver->menu_ctx->navigation_increment)
driver->menu_ctx->navigation_increment();
}
/**
@ -101,13 +105,14 @@ void menu_navigation_increment(menu_navigation_t *nav, unsigned scroll_speed)
void menu_navigation_set(menu_navigation_t *nav,
size_t idx, bool scroll)
{
driver_t *driver = driver_get_ptr();
if (!nav)
return;
nav->selection_ptr = idx;
if (driver.menu_ctx && driver.menu_ctx->navigation_set)
driver.menu_ctx->navigation_set(scroll);
if (driver->menu_ctx && driver->menu_ctx->navigation_set)
driver->menu_ctx->navigation_set(scroll);
}
/**
@ -117,14 +122,15 @@ void menu_navigation_set(menu_navigation_t *nav,
**/
void menu_navigation_set_last(menu_navigation_t *nav)
{
driver_t *driver = driver_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
if (!menu || !nav)
return;
nav->selection_ptr = menu_list_get_size(menu->menu_list) - 1;
if (driver.menu_ctx && driver.menu_ctx->navigation_set_last)
driver.menu_ctx->navigation_set_last();
if (driver->menu_ctx && driver->menu_ctx->navigation_set_last)
driver->menu_ctx->navigation_set_last();
}
/**
@ -139,6 +145,7 @@ void menu_navigation_set_last(menu_navigation_t *nav)
**/
void menu_navigation_descend_alphabet(menu_navigation_t *nav, size_t *ptr_out)
{
driver_t *driver = driver_get_ptr();
size_t i = 0, ptr = *ptr_out;
if (!nav)
return;
@ -155,8 +162,8 @@ void menu_navigation_descend_alphabet(menu_navigation_t *nav, size_t *ptr_out)
i--;
*ptr_out = nav->scroll.indices.list[i - 1];
if (driver.menu_ctx && driver.menu_ctx->navigation_descend_alphabet)
driver.menu_ctx->navigation_descend_alphabet(ptr_out);
if (driver->menu_ctx && driver->menu_ctx->navigation_descend_alphabet)
driver->menu_ctx->navigation_descend_alphabet(ptr_out);
}
/**
@ -171,6 +178,7 @@ void menu_navigation_descend_alphabet(menu_navigation_t *nav, size_t *ptr_out)
**/
void menu_navigation_ascend_alphabet(menu_navigation_t *nav, size_t *ptr_out)
{
driver_t *driver = driver_get_ptr();
size_t i = 0, ptr = *ptr_out;
if (!nav)
return;
@ -186,6 +194,6 @@ void menu_navigation_ascend_alphabet(menu_navigation_t *nav, size_t *ptr_out)
i++;
*ptr_out = nav->scroll.indices.list[i + 1];
if (driver.menu_ctx && driver.menu_ctx->navigation_descend_alphabet)
driver.menu_ctx->navigation_descend_alphabet(ptr_out);
if (driver->menu_ctx && driver->menu_ctx->navigation_descend_alphabet)
driver->menu_ctx->navigation_descend_alphabet(ptr_out);
}

13
menu/menu_setting.c
View File

@ -99,6 +99,7 @@ int menu_setting_handler(rarch_setting_t *setting, unsigned action)
static int menu_action_handle_setting(rarch_setting_t *setting,
unsigned type, unsigned action, bool wraparound)
{
driver_t *driver = driver_get_ptr();
if (!setting)
return -1;
@ -107,11 +108,11 @@ static int menu_action_handle_setting(rarch_setting_t *setting,
case ST_PATH:
if (action == MENU_ACTION_OK)
menu_list_push_stack_refresh(
driver.menu->menu_list,
driver->menu->menu_list,
setting->default_value.string,
setting->name,
type,
driver.menu->navigation.selection_ptr);
driver->menu->navigation.selection_ptr);
/* fall-through. */
case ST_BOOL:
case ST_INT:
@ -132,17 +133,19 @@ static int menu_action_handle_setting(rarch_setting_t *setting,
rarch_setting_t *menu_setting_find(const char *label)
{
driver_t *driver = driver_get_ptr();
return (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_settings, label);
driver->menu->list_settings, label);
}
int menu_setting_set(unsigned type, const char *label,
unsigned action, bool wraparound)
{
int ret = 0;
driver_t *driver = driver_get_ptr();
rarch_setting_t *setting = menu_setting_find(
driver.menu->menu_list->selection_buf->list
[driver.menu->navigation.selection_ptr].label);
driver->menu->menu_list->selection_buf->list
[driver->menu->navigation.selection_ptr].label);
if (!setting)
return 0;

21
menu/menu_shader.c
View File

@ -123,12 +123,13 @@ void menu_shader_manager_set_preset(struct video_shader *shader,
{
#ifdef HAVE_SHADER_MANAGER
config_file_t *conf = NULL;
driver_t *driver = driver_get_ptr();
g_settings.video.shader_enable = false;
if (!driver.video->set_shader)
if (!driver->video->set_shader)
return;
if (!driver.video->set_shader(driver.video_data,
if (!driver->video->set_shader(driver->video_data,
(enum rarch_shader_type)type, preset_path))
return;
@ -161,7 +162,7 @@ void menu_shader_manager_set_preset(struct video_shader *shader,
}
config_file_free(conf);
driver.menu->need_refresh = true;
driver->menu->need_refresh = true;
#endif
}
@ -180,14 +181,15 @@ void menu_shader_manager_save_preset(
unsigned d, type = RARCH_SHADER_NONE;
config_file_t *conf = NULL;
bool ret = false;
driver_t *driver = driver_get_ptr();
if (!driver.menu)
if (!driver->menu)
{
RARCH_ERR("Cannot save shader preset, menu handle is not initialized.\n");
return;
}
type = menu_shader_manager_get_type(driver.menu->shader);
type = menu_shader_manager_get_type(driver->menu->shader);
if (type == RARCH_SHADER_NONE)
return;
@ -210,7 +212,7 @@ void menu_shader_manager_save_preset(
else
{
const char *conf_path = (type == RARCH_SHADER_GLSL) ?
driver.menu->default_glslp : driver.menu->default_cgp;
driver->menu->default_glslp : driver->menu->default_cgp;
strlcpy(buffer, conf_path, sizeof(buffer));
}
@ -226,7 +228,7 @@ void menu_shader_manager_save_preset(
if (!(conf = (config_file_t*)config_file_new(NULL)))
return;
video_shader_write_conf_cgp(conf, driver.menu->shader);
video_shader_write_conf_cgp(conf, driver->menu->shader);
for (d = 0; d < ARRAY_SIZE(dirs); d++)
{
@ -303,9 +305,10 @@ unsigned menu_shader_manager_get_type(const struct video_shader *shader)
void menu_shader_manager_apply_changes(void)
{
#ifdef HAVE_SHADER_MANAGER
unsigned shader_type = menu_shader_manager_get_type(driver.menu->shader);
driver_t *driver = driver_get_ptr();
unsigned shader_type = menu_shader_manager_get_type(driver->menu->shader);
if (driver.menu->shader->passes
if (driver->menu->shader->passes
&& shader_type != RARCH_SHADER_NONE)
{
menu_shader_manager_save_preset(NULL, true);

3
menu/menu_texture.c
View File

@ -87,7 +87,8 @@ unsigned menu_texture_load(void *data,
if (g_settings.video.threaded
&& !g_extern.system.hw_render_callback.context_type)
{
thread_video_t *thr = (thread_video_t*)driver.video_data;
driver_t *driver = driver_get_ptr();
thread_video_t *thr = (thread_video_t*)driver->video_data;
if (!thr)
return 0;

24
netplay.c
View File

@ -186,8 +186,9 @@ static bool get_self_input_state(netplay_t *netplay)
unsigned i;
struct delta_frame *ptr = &netplay->buffer[netplay->self_ptr];
uint32_t state = 0;
driver_t *driver = driver_get_ptr();
if (!driver.block_libretro_input && netplay->frame_count > 0)
if (!driver->block_libretro_input && netplay->frame_count > 0)
{
/* First frame we always give zero input since relying on
* input from first frame screws up when we use -F 0. */
@ -475,7 +476,8 @@ static bool netplay_poll(netplay_t *netplay)
void input_poll_net(void)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay_should_skip(netplay) && netplay_can_poll(netplay))
netplay_poll(netplay);
}
@ -483,21 +485,24 @@ void input_poll_net(void)
void video_frame_net(const void *data, unsigned width,
unsigned height, size_t pitch)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay_should_skip(netplay))
netplay->cbs.frame_cb(data, width, height, pitch);
}
void audio_sample_net(int16_t left, int16_t right)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay_should_skip(netplay))
netplay->cbs.sample_cb(left, right);
}
size_t audio_sample_batch_net(const int16_t *data, size_t frames)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay_should_skip(netplay))
return netplay->cbs.sample_batch_cb(data, frames);
return frames;
@ -552,7 +557,8 @@ static int16_t netplay_input_state(netplay_t *netplay, bool port, unsigned devic
int16_t input_state_net(unsigned port, unsigned device,
unsigned idx, unsigned id)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (netplay_is_alive(netplay))
return netplay_input_state(netplay, port, device, idx, id);
return netplay->cbs.state_cb(port, device, idx, id);
@ -1352,7 +1358,8 @@ static void netplay_set_spectate_input(netplay_t *netplay, int16_t input)
int16_t input_state_spectate(unsigned port, unsigned device,
unsigned idx, unsigned id)
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
driver_t *driver = driver_get_ptr();
netplay_t *netplay = (netplay_t*)driver->netplay_data;
int16_t res = netplay->cbs.state_cb(port, device, idx, id);
netplay_set_spectate_input(netplay, res);
@ -1377,7 +1384,8 @@ static int16_t netplay_get_spectate_input(netplay_t *netplay, bool port,
int16_t input_state_spectate_client(unsigned port, unsigned device,
unsigned idx, unsigned id)
{
return netplay_get_spectate_input((netplay_t*)driver.netplay_data, port,
driver_t *driver = driver_get_ptr();
return netplay_get_spectate_input((netplay_t*)driver->netplay_data, port,
device, idx, id);
}

40
record/record_driver.c
View File

@ -92,8 +92,9 @@ void recording_dump_frame(const void *data, unsigned width,
unsigned height, size_t pitch)
{
struct ffemu_video_data ffemu_data = {0};
driver_t *driver = driver_get_ptr();
if (!driver.recording_data)
if (!driver->recording_data)
return;
ffemu_data.pitch = pitch;
@ -105,8 +106,8 @@ void recording_dump_frame(const void *data, unsigned width,
{
struct video_viewport vp = {0};
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (driver->video && driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
if (!vp.width || !vp.height)
{
@ -132,8 +133,8 @@ void recording_dump_frame(const void *data, unsigned width,
/* Big bottleneck.
* Since we might need to do read-backs asynchronously,
* it might take 3-4 times before this returns true. */
if (driver.video && driver.video->read_viewport)
if (!driver.video->read_viewport(driver.video_data,
if (driver->video && driver->video->read_viewport)
if (!driver->video->read_viewport(driver->video_data,
g_extern.record.gpu_buffer))
return;
@ -149,23 +150,25 @@ void recording_dump_frame(const void *data, unsigned width,
if (!g_extern.record.gpu_buffer)
ffemu_data.is_dupe = !data;
if (driver.recording && driver.recording->push_video)
driver.recording->push_video(driver.recording_data, &ffemu_data);
if (driver->recording && driver->recording->push_video)
driver->recording->push_video(driver->recording_data, &ffemu_data);
}
bool recording_deinit(void)
{
if (!driver.recording_data || !driver.recording)
driver_t *driver = driver_get_ptr();
if (!driver->recording_data || !driver->recording)
return false;
if (driver.recording->finalize)
driver.recording->finalize(driver.recording_data);
if (driver->recording->finalize)
driver->recording->finalize(driver->recording_data);
if (driver.recording->free)
driver.recording->free(driver.recording_data);
if (driver->recording->free)
driver->recording->free(driver->recording_data);
driver.recording_data = NULL;
driver.recording = NULL;
driver->recording_data = NULL;
driver->recording = NULL;
rarch_main_command(RARCH_CMD_GPU_RECORD_DEINIT);
@ -183,6 +186,7 @@ bool recording_init(void)
{
struct ffemu_params params = {0};
const struct retro_system_av_info *info = &g_extern.system.av_info;
driver_t *driver = driver_get_ptr();
if (!g_extern.record.enable)
return false;
@ -219,12 +223,12 @@ bool recording_init(void)
if (*g_extern.record.config)
params.config = g_extern.record.config;
if (g_settings.video.gpu_record && driver.video->read_viewport)
if (g_settings.video.gpu_record && driver->video->read_viewport)
{
struct video_viewport vp = {0};
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (driver->video && driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
if (!vp.width || !vp.height)
{
@ -295,7 +299,7 @@ bool recording_init(void)
params.fb_width, params.fb_height,
(unsigned)params.pix_fmt);
if (!ffemu_init_first(&driver.recording, &driver.recording_data, &params))
if (!ffemu_init_first(&driver->recording, &driver->recording_data, &params))
{
RARCH_ERR(RETRO_LOG_INIT_RECORDING_FAILED);
rarch_main_command(RARCH_CMD_GPU_RECORD_DEINIT);

179
retroarch.c
View File

@ -77,28 +77,31 @@
**/
void rarch_render_cached_frame(void)
{
void *recording = driver.recording_data;
void *recording = NULL;
driver_t *driver = driver_get_ptr();
runloop_t *runloop = rarch_main_get_ptr();
recording = driver->recording_data;
if (runloop->is_idle)
return;
/* Cannot allow recording when pushing duped frames. */
driver.recording_data = NULL;
driver->recording_data = NULL;
/* Not 100% safe, since the library might have
* freed the memory, but no known implementations do this.
* It would be really stupid at any rate ...
*/
if (driver.retro_ctx.frame_cb)
driver.retro_ctx.frame_cb(
if (driver->retro_ctx.frame_cb)
driver->retro_ctx.frame_cb(
(g_extern.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID)
? NULL : g_extern.frame_cache.data,
g_extern.frame_cache.width,
g_extern.frame_cache.height,
g_extern.frame_cache.pitch);
driver.recording_data = recording;
driver->recording_data = recording;
}
#include "config.features.h"
@ -882,9 +885,11 @@ static void init_remapping(void)
static void init_cheats(void)
{
driver_t *driver = driver_get_ptr();
bool allow_cheats = true;
#ifdef HAVE_NETPLAY
allow_cheats &= !driver.netplay_data;
allow_cheats &= !driver->netplay_data;
#endif
allow_cheats &= !g_extern.bsv.movie;
@ -897,8 +902,10 @@ static void init_cheats(void)
static void init_rewind(void)
{
void *state = NULL;
driver_t *driver = driver_get_ptr();
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
if (driver->netplay_data)
return;
#endif
@ -987,6 +994,7 @@ static void init_movie(void)
static bool init_netplay(void)
{
struct retro_callbacks cbs = {0};
driver_t *driver = driver_get_ptr();
if (!g_extern.netplay_enable)
return false;
@ -1007,13 +1015,13 @@ static bool init_netplay(void)
else
RARCH_LOG("Waiting for client...\n");
driver.netplay_data = (netplay_t*)netplay_new(
driver->netplay_data = (netplay_t*)netplay_new(
g_extern.netplay_is_client ? g_extern.netplay_server : NULL,
g_extern.netplay_port ? g_extern.netplay_port : RARCH_DEFAULT_PORT,
g_extern.netplay_sync_frames, &cbs, g_extern.netplay_is_spectate,
g_settings.username);
if (driver.netplay_data)
if (driver->netplay_data)
return true;
g_extern.netplay_is_client = false;
@ -1029,17 +1037,19 @@ static bool init_netplay(void)
#ifdef HAVE_COMMAND
static void init_command(void)
{
driver_t *driver = driver_get_ptr();
if (!g_settings.stdin_cmd_enable && !g_settings.network_cmd_enable)
return;
if (g_settings.stdin_cmd_enable && driver.stdin_claimed)
if (g_settings.stdin_cmd_enable && driver->stdin_claimed)
{
RARCH_WARN("stdin command interface is desired, but input driver has already claimed stdin.\n"
"Cannot use this command interface.\n");
}
if (!(driver.command = rarch_cmd_new(g_settings.stdin_cmd_enable
&& !driver.stdin_claimed,
if (!(driver->command = rarch_cmd_new(g_settings.stdin_cmd_enable
&& !driver->stdin_claimed,
g_settings.network_cmd_enable, g_settings.network_cmd_port)))
RARCH_ERR("Failed to initialize command interface.\n");
}
@ -1577,8 +1587,10 @@ static void check_disk_prev(
static void init_state(void)
{
driver.video_active = true;
driver.audio_active = true;
driver_t *driver = driver_get_ptr();
driver->video_active = true;
driver->audio_active = true;
}
/**
@ -1807,6 +1819,8 @@ static bool init_content(void)
static bool init_core(void)
{
driver_t *driver = driver_get_ptr();
verify_api_version();
pretro_init();
@ -1816,7 +1830,7 @@ static bool init_core(void)
if (!init_content())
return false;
retro_init_libretro_cbs(&driver.retro_ctx);
retro_init_libretro_cbs(&driver->retro_ctx);
init_system_av_info();
return true;
@ -1877,11 +1891,14 @@ int rarch_main_init(int argc, char *argv[])
rarch_main_command(RARCH_CMD_SAVEFILES_INIT);
#if defined(GEKKO) && defined(HW_RVL)
rarch_main_command(RARCH_CMD_VIDEO_SET_ASPECT_RATIO);
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data,
g_settings.video.aspect_ratio_idx);
{
driver_t *driver = driver_get_ptr();
rarch_main_command(RARCH_CMD_VIDEO_SET_ASPECT_RATIO);
if (driver->video_data && driver->video_poke
&& driver->video_poke->set_aspect_ratio)
driver->video_poke->set_aspect_ratio(driver->video_data,
g_settings.video.aspect_ratio_idx);
}
#endif
g_extern.error_in_init = false;
@ -1962,6 +1979,7 @@ void rarch_main_init_wrap(const struct rarch_main_wrap *args,
void rarch_main_set_state(unsigned cmd)
{
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
switch (cmd)
{
@ -1972,8 +1990,8 @@ void rarch_main_set_state(unsigned cmd)
if (!menu)
return;
if (driver.menu_ctx && driver.menu_ctx->toggle)
driver.menu_ctx->toggle(true);
if (driver->menu_ctx && driver->menu_ctx->toggle)
driver->menu_ctx->toggle(true);
/* Menu should always run with vsync on. */
rarch_main_command(RARCH_CMD_VIDEO_SET_BLOCKING_STATE);
@ -2001,32 +2019,32 @@ void rarch_main_set_state(unsigned cmd)
if (!menu_load_content())
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
#endif
if (driver.frontend_ctx && driver.frontend_ctx->content_loaded)
driver.frontend_ctx->content_loaded();
if (driver->frontend_ctx && driver->frontend_ctx->content_loaded)
driver->frontend_ctx->content_loaded();
break;
case RARCH_ACTION_STATE_MENU_RUNNING_FINISHED:
#ifdef HAVE_MENU
menu_apply_deferred_settings();
if (driver.menu_ctx && driver.menu_ctx->toggle)
driver.menu_ctx->toggle(false);
if (driver->menu_ctx && driver->menu_ctx->toggle)
driver->menu_ctx->toggle(false);
runloop->is_menu = false;
driver_set_nonblock_state(driver.nonblock_state);
driver_set_nonblock_state(driver->nonblock_state);
if (g_settings.menu.pause_libretro)
rarch_main_command(RARCH_CMD_AUDIO_START);
/* Prevent stray input from going to libretro core */
driver.flushing_input = true;
driver->flushing_input = true;
/* Restore libretro keyboard callback. */
g_extern.system.key_event = g_extern.frontend_key_event;
#endif
if (driver.video_data && driver.video_poke &&
driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data,
if (driver->video_data && driver->video_poke &&
driver->video_poke->set_texture_enable)
driver->video_poke->set_texture_enable(driver->video_data,
false, false);
break;
case RARCH_ACTION_STATE_QUIT:
@ -2169,6 +2187,7 @@ bool rarch_main_command(unsigned cmd)
unsigned i = 0;
bool boolean = false;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
(void)i;
@ -2220,7 +2239,7 @@ bool rarch_main_command(unsigned cmd)
return false;
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
if (driver->netplay_data)
return false;
#endif
main_state(cmd);
@ -2284,14 +2303,14 @@ bool rarch_main_command(unsigned cmd)
rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
break;
case RARCH_CMD_REINIT:
driver.video_cache_context =
driver->video_cache_context =
g_extern.system.hw_render_callback.cache_context;
driver.video_cache_context_ack = false;
driver->video_cache_context_ack = false;
rarch_main_command(RARCH_CMD_RESET_CONTEXT);
driver.video_cache_context = false;
driver->video_cache_context = false;
/* Poll input to avoid possibly stale data to corrupt things. */
driver.input->poll(driver.input_data);
driver->input->poll(driver->input_data);
#ifdef HAVE_MENU
runloop->frames.video.current.menu.framebuf.dirty = true;
@ -2316,7 +2335,7 @@ bool rarch_main_command(unsigned cmd)
break;
case RARCH_CMD_REWIND_DEINIT:
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
if (driver->netplay_data)
return false;
#endif
if (g_extern.rewind.state)
@ -2347,22 +2366,22 @@ bool rarch_main_command(unsigned cmd)
save_auto_state();
break;
case RARCH_CMD_AUDIO_STOP:
if (!driver.audio_data)
if (!driver->audio_data)
return false;
if (!driver.audio->alive(driver.audio_data))
if (!driver->audio->alive(driver->audio_data))
return false;
driver.audio->stop(driver.audio_data);
driver->audio->stop(driver->audio_data);
break;
case RARCH_CMD_AUDIO_START:
if (!driver.audio_data || driver.audio->alive(driver.audio_data))
if (!driver->audio_data || driver->audio->alive(driver->audio_data))
return false;
if (!g_settings.audio.mute_enable
&& !driver.audio->start(driver.audio_data))
&& !driver->audio->start(driver->audio_data))
{
RARCH_ERR("Failed to start audio driver. Will continue without audio.\n");
driver.audio_active = false;
driver->audio_active = false;
}
break;
case RARCH_CMD_AUDIO_MUTE_TOGGLE:
@ -2382,17 +2401,17 @@ bool rarch_main_command(unsigned cmd)
break;
case RARCH_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY
if (driver.overlay)
input_overlay_free(driver.overlay);
driver.overlay = NULL;
if (driver->overlay)
input_overlay_free(driver->overlay);
driver->overlay = NULL;
memset(&driver.overlay_state, 0, sizeof(driver.overlay_state));
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state));
#endif
break;
case RARCH_CMD_OVERLAY_INIT:
rarch_main_command(RARCH_CMD_OVERLAY_DEINIT);
#ifdef HAVE_OVERLAY
if (driver.osk_enable)
if (driver->osk_enable)
{
if (!*g_settings.osk.overlay)
break;
@ -2403,16 +2422,16 @@ bool rarch_main_command(unsigned cmd)
break;
}
driver.overlay = input_overlay_new(driver.osk_enable ? g_settings.osk.overlay : g_settings.input.overlay,
driver.osk_enable ? g_settings.osk.enable : g_settings.input.overlay_enable,
driver->overlay = input_overlay_new(driver->osk_enable ? g_settings.osk.overlay : g_settings.input.overlay,
driver->osk_enable ? g_settings.osk.enable : g_settings.input.overlay_enable,
g_settings.input.overlay_opacity, g_settings.input.overlay_scale);
if (!driver.overlay)
if (!driver->overlay)
RARCH_ERR("Failed to load overlay.\n");
#endif
break;
case RARCH_CMD_OVERLAY_NEXT:
#ifdef HAVE_OVERLAY
input_overlay_next(driver.overlay, g_settings.input.overlay_opacity);
input_overlay_next(driver->overlay, g_settings.input.overlay_opacity);
#endif
break;
case RARCH_CMD_DSP_FILTER_DEINIT:
@ -2478,37 +2497,37 @@ bool rarch_main_command(unsigned cmd)
return false;
break;
case RARCH_CMD_VIDEO_APPLY_STATE_CHANGES:
if (driver.video_data && driver.video_poke
&& driver.video_poke->apply_state_changes)
driver.video_poke->apply_state_changes(driver.video_data);
if (driver->video_data && driver->video_poke
&& driver->video_poke->apply_state_changes)
driver->video_poke->apply_state_changes(driver->video_data);
break;
case RARCH_CMD_VIDEO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case RARCH_CMD_VIDEO_SET_BLOCKING_STATE:
if (driver.video && driver.video->set_nonblock_state)
driver.video->set_nonblock_state(driver.video_data, boolean);
if (driver->video && driver->video->set_nonblock_state)
driver->video->set_nonblock_state(driver->video_data, boolean);
break;
case RARCH_CMD_VIDEO_SET_ASPECT_RATIO:
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data,
if (driver->video_data && driver->video_poke
&& driver->video_poke->set_aspect_ratio)
driver->video_poke->set_aspect_ratio(driver->video_data,
g_settings.video.aspect_ratio_idx);
break;
case RARCH_CMD_AUDIO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case RARCH_CMD_AUDIO_SET_BLOCKING_STATE:
if (driver.audio && driver.audio->set_nonblock_state)
driver.audio->set_nonblock_state(driver.audio_data, boolean);
if (driver->audio && driver->audio->set_nonblock_state)
driver->audio->set_nonblock_state(driver->audio_data, boolean);
break;
case RARCH_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY
input_overlay_set_scale_factor(driver.overlay,
input_overlay_set_scale_factor(driver->overlay,
g_settings.input.overlay_scale);
#endif
break;
case RARCH_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY
input_overlay_set_alpha_mod(driver.overlay,
input_overlay_set_alpha_mod(driver->overlay,
g_settings.input.overlay_opacity);
#endif
break;
@ -2538,8 +2557,8 @@ bool rarch_main_command(unsigned cmd)
SALAMANDER_FILE,
sizeof(g_extern.fullpath));
#endif
if (driver.frontend_ctx && driver.frontend_ctx->set_fork)
driver.frontend_ctx->set_fork(true, false);
if (driver->frontend_ctx && driver->frontend_ctx->set_fork)
driver->frontend_ctx->set_fork(true, false);
break;
case RARCH_CMD_MENU_SAVE_CONFIG:
if (!save_core_config())
@ -2629,7 +2648,7 @@ bool rarch_main_command(unsigned cmd)
case RARCH_CMD_SAVEFILES_INIT:
g_extern.use_sram = g_extern.use_sram && !g_extern.sram_save_disable
#ifdef HAVE_NETPLAY
&& (!driver.netplay_data || !g_extern.netplay_is_client)
&& (!driver->netplay_data || !g_extern.netplay_is_client)
#endif
;
@ -2659,10 +2678,10 @@ bool rarch_main_command(unsigned cmd)
case RARCH_CMD_NETPLAY_DEINIT:
#ifdef HAVE_NETPLAY
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (netplay)
netplay_free(netplay);
driver.netplay_data = NULL;
driver->netplay_data = NULL;
}
#endif
break;
@ -2686,7 +2705,7 @@ bool rarch_main_command(unsigned cmd)
case RARCH_CMD_NETPLAY_FLIP_PLAYERS:
#ifdef HAVE_NETPLAY
{
netplay_t *netplay = (netplay_t*)driver.netplay_data;
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay)
return false;
netplay_flip_users(netplay);
@ -2694,11 +2713,11 @@ bool rarch_main_command(unsigned cmd)
#endif
break;
case RARCH_CMD_FULLSCREEN_TOGGLE:
if (!driver.video)
if (!driver->video)
return false;
/* If video driver/context does not support windowed
* mode, don't perform command. */
if (!driver.video->has_windowed(driver.video_data))
if (!driver->video->has_windowed(driver->video_data))
return false;
/* If we go fullscreen we drop all drivers and
@ -2708,9 +2727,9 @@ bool rarch_main_command(unsigned cmd)
break;
case RARCH_CMD_COMMAND_DEINIT:
#ifdef HAVE_COMMAND
if (driver.command)
rarch_cmd_free(driver.command);
driver.command = NULL;
if (driver->command)
rarch_cmd_free(driver->command);
driver->command = NULL;
#endif
break;
case RARCH_CMD_COMMAND_INIT:
@ -2795,17 +2814,17 @@ bool rarch_main_command(unsigned cmd)
{
static bool grab_mouse_state = false;
if (!driver.input || !driver.input->grab_mouse)
if (!driver->input || !driver->input->grab_mouse)
return false;
grab_mouse_state = !grab_mouse_state;
RARCH_LOG("Grab mouse state: %s.\n",
grab_mouse_state ? "yes" : "no");
driver.input->grab_mouse(driver.input_data, grab_mouse_state);
driver->input->grab_mouse(driver->input_data, grab_mouse_state);
if (driver.video_poke && driver.video_poke->show_mouse)
driver.video_poke->show_mouse(
driver.video_data, !grab_mouse_state);
if (driver->video_poke && driver->video_poke->show_mouse)
driver->video_poke->show_mouse(
driver->video_data, !grab_mouse_state);
}
break;
case RARCH_CMD_PERFCNT_REPORT_FRONTEND_LOG:

63
runloop.c
View File

@ -139,18 +139,20 @@ static INLINE bool check_is_oneshot(bool oneshot_pressed, bool rewind_pressed)
static void check_fast_forward_button(bool fastforward_pressed,
bool hold_pressed, bool old_hold_pressed)
{
driver_t *driver = driver_get_ptr();
/* To avoid continous switching if we hold the button down, we require
* that the button must go from pressed to unpressed back to pressed
* to be able to toggle between then.
*/
if (fastforward_pressed)
driver.nonblock_state = !driver.nonblock_state;
driver->nonblock_state = !driver->nonblock_state;
else if (old_hold_pressed != hold_pressed)
driver.nonblock_state = hold_pressed;
driver->nonblock_state = hold_pressed;
else
return;
driver_set_nonblock_state(driver.nonblock_state);
driver_set_nonblock_state(driver->nonblock_state);
}
/**
@ -564,6 +566,8 @@ static int do_state_checks(
retro_input_t input, retro_input_t old_input,
retro_input_t trigger_input)
{
driver_t *driver = driver_get_ptr();
if (g_runloop.is_idle)
return 1;
@ -579,7 +583,7 @@ static int do_state_checks(
set_volume(-0.5f);
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
if (driver->netplay_data)
return do_netplay_state_checks(input,
old_input, trigger_input);
#endif
@ -659,10 +663,11 @@ static INLINE int time_to_exit(retro_input_t input)
**/
static void rarch_update_frame_time(void)
{
driver_t *driver = driver_get_ptr();
retro_time_t curr_time = rarch_get_time_usec();
retro_time_t delta = curr_time - g_extern.system.frame_time_last;
bool is_locked_fps = g_runloop.is_paused || driver.nonblock_state;
is_locked_fps |= !!driver.recording_data;
bool is_locked_fps = g_runloop.is_paused || driver->nonblock_state;
is_locked_fps |= !!driver->recording_data;
if (!g_extern.system.frame_time_last || is_locked_fps)
delta = g_extern.system.frame_time.reference;
@ -726,10 +731,11 @@ static bool check_block_hotkey(bool enable_hotkey)
&g_settings.input.binds[0][RARCH_ENABLE_HOTKEY];
static const struct retro_keybind *autoconf_bind =
&g_settings.input.autoconf_binds[0][RARCH_ENABLE_HOTKEY];
driver_t *driver = driver_get_ptr();
/* Don't block the check to RARCH_ENABLE_HOTKEY
* unless we're really supposed to. */
driver.block_hotkey = driver.block_input;
driver->block_hotkey = driver->block_input;
// If we haven't bound anything to this, always allow hotkeys.
use_hotkey_enable = bind->key != RETROK_UNKNOWN ||
@ -739,7 +745,7 @@ static bool check_block_hotkey(bool enable_hotkey)
autoconf_bind->joykey != NO_BTN ||
autoconf_bind->joyaxis != AXIS_NONE;
driver.block_hotkey = driver.block_input ||
driver->block_hotkey = driver->block_input ||
(use_hotkey_enable && !enable_hotkey);
/* If we hold ENABLE_HOTKEY button, block all libretro input to allow
@ -780,14 +786,15 @@ static INLINE retro_input_t input_keys_pressed(void)
g_settings.input.binds[15],
};
retro_input_t ret = 0;
driver_t *driver = driver_get_ptr();
if (!driver.input || !driver.input_data)
if (!driver->input || !driver->input_data)
return 0;
g_extern.turbo_count++;
driver.block_libretro_input = check_block_hotkey(
driver.input->key_pressed(driver.input_data,
driver->block_libretro_input = check_block_hotkey(
driver->input->key_pressed(driver->input_data,
RARCH_ENABLE_HOTKEY));
for (i = 0; i < g_settings.input.max_users; i++)
@ -800,12 +807,12 @@ static INLINE retro_input_t input_keys_pressed(void)
g_extern.turbo_frame_enable[i] = 0;
}
if (!driver.block_libretro_input)
if (!driver->block_libretro_input)
{
for (i = 0; i < g_settings.input.max_users; i++)
{
g_extern.turbo_frame_enable[i] =
driver.input->input_state(driver.input_data, binds, i,
driver->input->input_state(driver->input_data, binds, i,
RETRO_DEVICE_JOYPAD, 0, RARCH_TURBO_ENABLE);
}
}
@ -872,18 +879,19 @@ static int rarch_main_iterate_quit(void)
static void rarch_main_iterate_linefeed_overlay(void)
{
static char prev_overlay_restore = false;
driver_t *driver = driver_get_ptr();
if (driver.osk_enable && !driver.keyboard_linefeed_enable)
if (driver->osk_enable && !driver->keyboard_linefeed_enable)
{
driver.osk_enable = false;
prev_overlay_restore = true;
driver->osk_enable = false;
prev_overlay_restore = true;
rarch_main_command(RARCH_CMD_OVERLAY_DEINIT);
return;
}
else if (!driver.osk_enable && driver.keyboard_linefeed_enable)
else if (!driver->osk_enable && driver->keyboard_linefeed_enable)
{
driver.osk_enable = true;
prev_overlay_restore = false;
driver->osk_enable = true;
prev_overlay_restore = false;
rarch_main_command(RARCH_CMD_OVERLAY_INIT);
return;
}
@ -951,9 +959,10 @@ int rarch_main_iterate(void)
retro_input_t old_input = last_input;
retro_input_t input = input_keys_pressed();
last_input = input;
driver_t *driver = driver_get_ptr();
if (driver.flushing_input)
driver.flushing_input = (input) ? input_flush(&input) : false;
if (driver->flushing_input)
driver->flushing_input = (input) ? input_flush(&input) : false;
trigger_input = input & ~old_input;
@ -994,7 +1003,7 @@ int rarch_main_iterate(void)
if (do_state_checks(input, old_input, trigger_input))
{
/* RetroArch has been paused */
driver.retro_ctx.poll_cb();
driver->retro_ctx.poll_cb();
rarch_sleep(10);
return 1;
@ -1005,8 +1014,8 @@ int rarch_main_iterate(void)
#endif
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
netplay_pre_frame((netplay_t*)driver.netplay_data);
if (driver->netplay_data)
netplay_pre_frame((netplay_t*)driver->netplay_data);
#endif
if (g_extern.bsv.movie)
@ -1027,7 +1036,7 @@ int rarch_main_iterate(void)
g_settings.input.analog_dpad_mode[i]);
}
if ((g_settings.video.frame_delay > 0) && !driver.nonblock_state)
if ((g_settings.video.frame_delay > 0) && !driver->nonblock_state)
rarch_sleep(g_settings.video.frame_delay);
@ -1047,8 +1056,8 @@ int rarch_main_iterate(void)
bsv_movie_set_frame_end(g_extern.bsv.movie);
#ifdef HAVE_NETPLAY
if (driver.netplay_data)
netplay_post_frame((netplay_t*)driver.netplay_data);
if (driver->netplay_data)
netplay_post_frame((netplay_t*)driver->netplay_data);
#endif
#if defined(HAVE_THREADS)

38
runloop_data.c
View File

@ -239,6 +239,7 @@ static int rarch_main_data_http_iterate_poll(http_handle_t *http)
static int cb_image_menu_wallpaper_upload(void *data, size_t len)
{
nbio_handle_t *nbio = (nbio_handle_t*)data;
driver_t *driver = driver_get_ptr();
if (!nbio || !data)
return -1;
@ -247,8 +248,8 @@ static int cb_image_menu_wallpaper_upload(void *data, size_t len)
nbio->image.processing_final_state == IMAGE_PROCESS_ERROR_END)
return -1;
if (driver.menu_ctx && driver.menu_ctx->load_background)
driver.menu_ctx->load_background(&nbio->image.ti);
if (driver->menu_ctx && driver->menu_ctx->load_background)
driver->menu_ctx->load_background(&nbio->image.ti);
texture_image_free(&nbio->image.ti);
@ -591,24 +592,26 @@ static int rarch_main_data_nbio_iterate_parse(nbio_handle_t *nbio)
#ifdef HAVE_MENU
static void rarch_main_data_rdl_iterate(void)
{
if (!driver.menu->rdl)
driver_t *driver = driver_get_ptr();
if (!driver->menu->rdl)
return;
if (driver.menu->rdl->blocking)
if (driver->menu->rdl->blocking)
{
/* Do nonblocking I/O transfers here. */
return;
}
#ifdef HAVE_LIBRETRODB
if (!driver.menu->rdl->iterating)
if (!driver->menu->rdl->iterating)
{
database_info_write_rdl_free(driver.menu->rdl);
driver.menu->rdl = NULL;
database_info_write_rdl_free(driver->menu->rdl);
driver->menu->rdl = NULL;
return;
}
database_info_write_rdl_iterate(driver.menu->rdl);
database_info_write_rdl_iterate(driver->menu->rdl);
#endif
}
@ -675,8 +678,9 @@ static void rarch_main_data_http_iterate(http_handle_t *http)
static void rarch_main_data_db_iterate(void)
{
driver_t *driver = driver_get_ptr();
#ifdef HAVE_MENU
if (driver.menu && driver.menu->rdl)
if (driver->menu && driver->menu->rdl)
rarch_main_data_rdl_iterate();
#endif
}
@ -685,30 +689,32 @@ static void rarch_main_data_db_iterate(void)
static void rarch_main_data_overlay_iterate(void)
{
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
if (runloop->is_idle)
return;
if (!driver.overlay)
if (!driver->overlay)
return;
switch (driver.overlay->state)
switch (driver->overlay->state)
{
case OVERLAY_STATUS_NONE:
case OVERLAY_STATUS_ALIVE:
break;
case OVERLAY_STATUS_DEFERRED_LOAD:
input_overlay_load_overlays(driver.overlay);
input_overlay_load_overlays(driver->overlay);
break;
case OVERLAY_STATUS_DEFERRED_LOADING:
input_overlay_load_overlays_iterate(driver.overlay);
input_overlay_load_overlays_iterate(driver->overlay);
break;
case OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE:
input_overlay_load_overlays_resolve_iterate(driver.overlay);
input_overlay_load_overlays_resolve_iterate(driver->overlay);
break;
case OVERLAY_STATUS_DEFERRED_DONE:
input_overlay_new_done(driver.overlay);
input_overlay_new_done(driver->overlay);
break;
case OVERLAY_STATUS_DEFERRED_ERROR:
input_overlay_free(driver.overlay);
input_overlay_free(driver->overlay);
break;
default:
break;

26
screenshot.c
View File

@ -178,9 +178,10 @@ static bool take_screenshot_viewport(void)
uint8_t *buffer = NULL;
bool retval = false;
struct video_viewport vp = {0};
driver_t *driver = driver_get_ptr();
if (driver.video && driver.video->viewport_info)
driver.video->viewport_info(driver.video_data, &vp);
if (driver->video && driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
if (!vp.width || !vp.height)
return false;
@ -188,8 +189,8 @@ static bool take_screenshot_viewport(void)
if (!(buffer = (uint8_t*)malloc(vp.width * vp.height * 3)))
return false;
if (driver.video && driver.video->read_viewport)
if (!driver.video->read_viewport(driver.video_data, buffer))
if (driver->video && driver->video->read_viewport)
if (!driver->video->read_viewport(driver->video_data, buffer))
goto done;
screenshot_dir = g_settings.screenshot_directory;
@ -249,6 +250,7 @@ bool take_screenshot(void)
bool ret = true;
const char *msg = NULL;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
/* No way to infer screenshot directory. */
if ((!*g_settings.screenshot_directory) && (!*g_extern.basename))
@ -256,19 +258,19 @@ bool take_screenshot(void)
viewport_read = (g_settings.video.gpu_screenshot ||
((g_extern.system.hw_render_callback.context_type
!= RETRO_HW_CONTEXT_NONE) && !driver.video->read_frame_raw))
&& driver.video->read_viewport && driver.video->viewport_info;
!= RETRO_HW_CONTEXT_NONE) && !driver->video->read_frame_raw))
&& driver->video->read_viewport && driver->video->viewport_info;
if (viewport_read)
{
#ifdef HAVE_MENU
/* Avoid taking screenshot of GUI overlays. */
if (driver.video_poke && driver.video_poke->set_texture_enable)
driver.video_poke->set_texture_enable(driver.video_data,
if (driver->video_poke && driver->video_poke->set_texture_enable)
driver->video_poke->set_texture_enable(driver->video_data,
false, false);
#endif
if (driver.video)
if (driver->video)
rarch_render_cached_frame();
}
@ -277,15 +279,15 @@ bool take_screenshot(void)
else if (g_extern.frame_cache.data &&
(g_extern.frame_cache.data != RETRO_HW_FRAME_BUFFER_VALID))
ret = take_screenshot_raw();
else if (driver.video->read_frame_raw)
else if (driver->video->read_frame_raw)
{
const void* old_data = g_extern.frame_cache.data;
unsigned old_width = g_extern.frame_cache.width;
unsigned old_height = g_extern.frame_cache.height;
size_t old_pitch = g_extern.frame_cache.pitch;
void* frame_data = driver.video->read_frame_raw
(driver.video_data, &g_extern.frame_cache.width,
void* frame_data = driver->video->read_frame_raw
(driver->video_data, &g_extern.frame_cache.width,
&g_extern.frame_cache.height, &g_extern.frame_cache.pitch);
if (frame_data)

16
settings_data.c
View File

@ -2967,6 +2967,7 @@ static void general_write_handler(void *data)
{
unsigned rarch_cmd = RARCH_CMD_NONE;
rarch_setting_t *setting = (rarch_setting_t*)data;
driver_t *driver = driver_get_ptr();
if (!setting)
return;
@ -3005,9 +3006,9 @@ static void general_write_handler(void *data)
}
else if (!strcmp(setting->name, "video_smooth"))
{
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_filtering)
driver.video_poke->set_filtering(driver.video_data,
if (driver->video_data && driver->video_poke
&& driver->video_poke->set_filtering)
driver->video_poke->set_filtering(driver->video_data,
1, g_settings.video.smooth);
}
else if (!strcmp(setting->name, "pal60_enable"))
@ -3019,8 +3020,8 @@ static void general_write_handler(void *data)
}
else if (!strcmp(setting->name, "video_rotation"))
{
if (driver.video && driver.video->set_rotation)
driver.video->set_rotation(driver.video_data,
if (driver->video && driver->video->set_rotation)
driver->video->set_rotation(driver->video_data,
(*setting->value.unsigned_integer +
g_extern.system.rotation) % 4);
}
@ -3060,7 +3061,7 @@ static void general_write_handler(void *data)
g_settings.audio.max_timing_skew = *setting->value.fraction;
else if (!strcmp(setting->name, "video_refresh_rate_auto"))
{
if (driver.video && driver.video_data)
if (driver->video && driver->video_data)
{
driver_set_refresh_rate(*setting->value.fraction);
@ -3282,6 +3283,7 @@ static bool setting_data_append_list_main_menu_options(
{
rarch_setting_group_info_t group_info;
rarch_setting_group_info_t subgroup_info;
driver_t *driver = driver_get_ptr();
START_GROUP(group_info, "Main Menu");
START_SUB_GROUP(list, list_info, "State", group_info.name, subgroup_info);
@ -3320,7 +3322,7 @@ static bool setting_data_append_list_main_menu_options(
subgroup_info.name);
}
if (
driver.menu
driver->menu
&& g_extern.core_info
&& core_info_list_num_info_files(g_extern.core_info))
{

5
tools/retroarch-joyconfig.c
View File

@ -46,6 +46,11 @@ static char *g_auto_path = NULL;
static char *g_driver = NULL;
static unsigned g_meta_level = 0;
driver_t *driver_get_ptr(void)
{
return &driver;
}
static void print_help(void)
{
puts("=====================");