gaming/RetroArch
gaming/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2024-07-08 20:25:47 +00:00
Code Issues Projects Releases Wiki Activity

Start replacing more g_settings usages

Browse Source
This commit is contained in:
twinaphex 2015-03-20 20:43:22 +01:00
parent e4ffbf0008
commit 7bc845006b
19 changed files with 203 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
audio/audio_monitor.c
View File

@ -22,16 +22,17 @@ void audio_monitor_adjust_system_rates(void)
float timing_skew;
const struct retro_system_timing *info =
(const struct retro_system_timing*)&g_extern.system.av_info.timing;
settings_t *settings = config_get_ptr();
if (info->sample_rate <= 0.0)
return;
timing_skew = fabs(1.0f - info->fps /
g_settings.video.refresh_rate);
settings->video.refresh_rate);
g_extern.audio_data.in_rate = info->sample_rate;
if (timing_skew <= g_settings.audio.max_timing_skew)
g_extern.audio_data.in_rate *= (g_settings.video.refresh_rate / info->fps);
if (timing_skew <= settings->audio.max_timing_skew)
g_extern.audio_data.in_rate *= (settings->video.refresh_rate / info->fps);
RARCH_LOG("Set audio input rate to: %.2f Hz.\n",
g_extern.audio_data.in_rate);
@ -44,7 +45,8 @@ void audio_monitor_adjust_system_rates(void)
**/
void audio_monitor_set_refresh_rate(void)
{
double new_src_ratio = (double)g_settings.audio.out_rate /
settings_t *settings = config_get_ptr();
double new_src_ratio = (double)settings->audio.out_rate /
g_extern.audio_data.in_rate;
g_extern.audio_data.orig_src_ratio = new_src_ratio;

3
cheats.c
View File

@ -59,8 +59,9 @@ bool cheat_manager_save(cheat_manager_t *handle, const char *path)
char buf[PATH_MAX_LENGTH];
char cheats_file[PATH_MAX_LENGTH];
config_file_t *conf = NULL;
settings_t *settings = config_get_ptr();
fill_pathname_join(buf, g_settings.cheat_database,
fill_pathname_join(buf, settings->cheat_database,
path, sizeof(buf));
fill_pathname_noext(cheats_file, buf, ".cht", sizeof(cheats_file));

17
content.c
View File

@ -181,13 +181,12 @@ bool save_state(const char *path)
bool load_state(const char *path)
{
unsigned i;
ssize_t size;
unsigned num_blocks = 0;
bool ret = true;
void *buf = NULL;
struct sram_block *blocks = NULL;
ssize_t size;
ret = read_file(path, &buf, &size);
settings_t *settings = config_get_ptr();
bool ret = read_file(path, &buf, &size);
RARCH_LOG("Loading state: \"%s\".\n", path);
@ -199,7 +198,7 @@ bool load_state(const char *path)
RARCH_LOG("State size: %u bytes.\n", (unsigned)size);
if (g_settings.block_sram_overwrite && g_extern.savefiles
if (settings->block_sram_overwrite && g_extern.savefiles
&& g_extern.savefiles->size)
{
RARCH_LOG("Blocking SRAM overwrite.\n");
@ -351,6 +350,7 @@ static bool load_content_need_fullpath(
char new_path[PATH_MAX_LENGTH], new_basedir[PATH_MAX_LENGTH];
ssize_t len;
union string_list_elem_attr attributes;
settings_t *settings = config_get_ptr();
bool ret = false;
if (g_extern.system.info.block_extract)
@ -365,7 +365,7 @@ static bool load_content_need_fullpath(
RARCH_LOG("Compressed file in case of need_fullpath."
"Now extracting to temporary directory.\n");
strlcpy(new_basedir, g_settings.extraction_directory,
strlcpy(new_basedir, settings->extraction_directory,
sizeof(new_basedir));
if ((!strcmp(new_basedir, "")) ||
@ -504,6 +504,7 @@ bool init_content_file(void)
bool ret = false;
struct string_list *content = NULL;
const struct retro_subsystem_info *special = NULL;
settings_t *settings = config_get_ptr();
g_extern.temporary_content = string_list_new();
@ -597,8 +598,8 @@ bool init_content_file(void)
if (!zlib_extract_first_content_file(temporary_content,
sizeof(temporary_content), valid_ext,
*g_settings.extraction_directory ?
g_settings.extraction_directory : NULL))
*settings->extraction_directory ?
settings->extraction_directory : NULL))
{
RARCH_ERR("Failed to extract content from zipped file: %s.\n",
temporary_content);

6
driver.c
View File

@ -243,19 +243,21 @@ void driver_set_refresh_rate(float hz)
**/
void driver_set_nonblock_state(bool enable)
{
settings_t *settings = config_get_ptr();
/* Only apply non-block-state for video if we're using vsync. */
if (driver.video_active && driver.video_data)
{
bool video_nonblock = enable;
if (!g_settings.video.vsync || g_extern.system.force_nonblock)
if (!settings->video.vsync || g_extern.system.force_nonblock)
video_nonblock = true;
driver.video->set_nonblock_state(driver.video_data, video_nonblock);
}
if (driver.audio_active && driver.audio_data)
driver.audio->set_nonblock_state(driver.audio_data,
g_settings.audio.sync ? enable : true);
settings->audio.sync ? enable : true);
g_extern.audio_data.chunk_size = enable ?
g_extern.audio_data.nonblock_chunk_size :

19
frontend/frontend.c
View File

@ -58,7 +58,8 @@
**/
void main_exit_save_config(void)
{
if (g_settings.config_save_on_exit && *g_extern.config_path)
settings_t *settings = config_get_ptr();
if (settings->config_save_on_exit && *g_extern.config_path)
{
/* Save last core-specific config to the default config location,
* needed on consoles for core switching and reusing last good
@ -68,7 +69,7 @@ void main_exit_save_config(void)
/* Flush out the core specific config. */
if (*g_extern.core_specific_config_path &&
g_settings.core_specific_config)
settings->core_specific_config)
config_save_file(g_extern.core_specific_config_path);
}
@ -85,7 +86,8 @@ void main_exit_save_config(void)
**/
void main_exit(args_type() args)
{
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
g_extern.system.shutdown = false;
@ -110,8 +112,8 @@ void main_exit(args_type() args)
driver->frontend_ctx->deinit(args);
if (driver->frontend_ctx && driver->frontend_ctx->exitspawn)
driver->frontend_ctx->exitspawn(g_settings.libretro,
sizeof(g_settings.libretro));
driver->frontend_ctx->exitspawn(settings->libretro,
sizeof(settings->libretro));
rarch_main_state_free();
@ -275,6 +277,7 @@ returntype main_entry(signature())
declare_argv();
args_type() args = (args_type())args_initial_ptr();
int ret = 0;
settings_t *settings = NULL;
driver_t *driver = driver_get_ptr();
driver->frontend_ctx = (frontend_ctx_driver_t*)frontend_ctx_init_first();
@ -299,12 +302,14 @@ returntype main_entry(signature())
rarch_main_command(RARCH_CMD_HISTORY_INIT);
if (g_settings.history_list_enable)
settings = config_get_ptr();
if (settings->history_list_enable)
{
if (g_extern.content_is_init || g_extern.system.no_content)
history_playlist_push(g_defaults.history,
g_extern.fullpath,
g_settings.libretro,
settings->libretro,
&g_extern.system.info);
}

18
gfx/video_context_driver.c
View File

@ -98,12 +98,13 @@ static int find_gfx_ctx_driver_index(const char *ident)
**/
void find_prev_gfx_context_driver(void)
{
int i = find_gfx_ctx_driver_index(g_settings.video.context_driver);
settings_t *settings = config_get_ptr();
int i = find_gfx_ctx_driver_index(settings->video.context_driver);
if (i > 0)
{
strlcpy(g_settings.video.context_driver, gfx_ctx_drivers[i - 1]->ident,
sizeof(g_settings.video.context_driver));
strlcpy(settings->video.context_driver, gfx_ctx_drivers[i - 1]->ident,
sizeof(settings->video.context_driver));
}
else
RARCH_WARN("Couldn't find any previous video context driver.\n");
@ -116,12 +117,13 @@ void find_prev_gfx_context_driver(void)
**/
void find_next_context_driver(void)
{
int i = find_gfx_ctx_driver_index(g_settings.video.context_driver);
settings_t *settings = config_get_ptr();
int i = find_gfx_ctx_driver_index(settings->video.context_driver);
if (i >= 0 && gfx_ctx_drivers[i + 1])
{
strlcpy(g_settings.video.context_driver, gfx_ctx_drivers[i + 1]->ident,
sizeof(g_settings.video.context_driver));
strlcpy(settings->video.context_driver, gfx_ctx_drivers[i + 1]->ident,
sizeof(settings->video.context_driver));
}
else
RARCH_WARN("Couldn't find any next video context driver.\n");
@ -148,6 +150,8 @@ static const gfx_ctx_driver_t *gfx_ctx_init(void *data,
enum gfx_ctx_api api, unsigned major,
unsigned minor, bool hw_render_ctx)
{
settings_t *settings = config_get_ptr();
if (ctx->bind_api(data, api, major, minor))
{
bool initialized = ctx->init(data);
@ -157,7 +161,7 @@ static const gfx_ctx_driver_t *gfx_ctx_init(void *data,
if (ctx->bind_hw_render)
ctx->bind_hw_render(data,
g_settings.video.shared_context && hw_render_ctx);
settings->video.shared_context && hw_render_ctx);
return ctx;
}

69
gfx/video_driver.c
View File

@ -148,7 +148,8 @@ const char* config_get_video_driver_options(void)
void find_video_driver(void)
{
int i;
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
#if defined(HAVE_OPENGL) && defined(HAVE_FBO)
if (g_extern.system.hw_render_callback.context_type)
@ -169,14 +170,14 @@ void find_video_driver(void)
RARCH_WARN("Frontend supports get_video_driver() but did not specify one.\n");
}
i = find_driver_index("video_driver", g_settings.video.driver);
i = find_driver_index("video_driver", settings->video.driver);
if (i >= 0)
driver->video = (const video_driver_t*)video_driver_find_handle(i);
else
{
unsigned d;
RARCH_ERR("Couldn't find any video driver named \"%s\"\n",
g_settings.video.driver);
settings->video.driver);
RARCH_LOG_OUTPUT("Available video drivers are:\n");
for (d = 0; video_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", video_driver_find_ident(d));
@ -200,9 +201,11 @@ void find_video_driver(void)
**/
void *video_driver_resolve(const video_driver_t **drv)
{
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
#ifdef HAVE_THREADS
if (g_settings.video.threaded
if (settings->video.threaded
&& !g_extern.system.hw_render_callback.context_type)
return rarch_threaded_video_resolve(drv);
#endif
@ -281,10 +284,11 @@ static void init_video_filter(enum retro_pixel_format colfmt)
{
unsigned width, height, pow2_x, pow2_y, maxsize;
struct retro_game_geometry *geom = NULL;
settings_t *settings = config_get_ptr();
deinit_video_filter();
if (!*g_settings.video.softfilter_plugin)
if (!*settings->video.softfilter_plugin)
return;
/* Deprecated format. Gets pre-converted. */
@ -302,7 +306,7 @@ static void init_video_filter(enum retro_pixel_format colfmt)
height = geom->max_height;
g_extern.filter.filter = rarch_softfilter_new(
g_settings.video.softfilter_plugin,
settings->video.softfilter_plugin,
RARCH_SOFTFILTER_THREADS_AUTO, colfmt, width, height);
if (!g_extern.filter.filter)
@ -403,8 +407,9 @@ void init_video(void)
const struct retro_game_geometry *geom = NULL;
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();
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
init_video_filter(g_extern.system.pix_fmt);
rarch_main_command(RARCH_CMD_SHADER_DIR_INIT);
@ -424,7 +429,7 @@ void init_video(void)
/* Update CUSTOM viewport. */
custom_vp = &g_extern.console.screen.viewports.custom_vp;
if (g_settings.video.aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
if (settings->video.aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
{
float default_aspect = aspectratio_lut[ASPECT_RATIO_CORE].value;
aspectratio_lut[ASPECT_RATIO_CUSTOM].value =
@ -433,27 +438,27 @@ void init_video(void)
}
g_extern.system.aspect_ratio =
aspectratio_lut[g_settings.video.aspect_ratio_idx].value;
aspectratio_lut[settings->video.aspect_ratio_idx].value;
if (g_settings.video.fullscreen)
if (settings->video.fullscreen)
{
width = g_settings.video.fullscreen_x;
height = g_settings.video.fullscreen_y;
width = settings->video.fullscreen_x;
height = settings->video.fullscreen_y;
}
else
{
if (g_settings.video.force_aspect)
if (settings->video.force_aspect)
{
/* Do rounding here to simplify integer scale correctness. */
unsigned base_width = roundf(geom->base_height *
g_extern.system.aspect_ratio);
width = roundf(base_width * g_settings.video.scale);
height = roundf(geom->base_height * g_settings.video.scale);
width = roundf(base_width * settings->video.scale);
height = roundf(geom->base_height * settings->video.scale);
}
else
{
width = roundf(geom->base_width * g_settings.video.scale);
height = roundf(geom->base_height * g_settings.video.scale);
width = roundf(geom->base_width * settings->video.scale);
height = roundf(geom->base_height * settings->video.scale);
}
}
@ -472,18 +477,18 @@ void init_video(void)
rarch_fail(1, "init_video()");
}
video.width = width;
video.height = height;
video.fullscreen = g_settings.video.fullscreen;
video.vsync = g_settings.video.vsync && !g_extern.system.force_nonblock;
video.force_aspect = g_settings.video.force_aspect;
video.width = width;
video.height = height;
video.fullscreen = settings->video.fullscreen;
video.vsync = settings->video.vsync && !g_extern.system.force_nonblock;
video.force_aspect = settings->video.force_aspect;
#ifdef GEKKO
video.viwidth = g_settings.video.viwidth;
video.vfilter = g_settings.video.vfilter;
video.viwidth = settings->video.viwidth;
video.vfilter = settings->video.vfilter;
#endif
video.smooth = g_settings.video.smooth;
video.input_scale = scale;
video.rgb32 = g_extern.filter.filter ?
video.smooth = settings->video.smooth;
video.input_scale = scale;
video.rgb32 = g_extern.filter.filter ?
g_extern.filter.out_rgb32 :
(g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888);
@ -492,7 +497,7 @@ void init_video(void)
find_video_driver();
#ifdef HAVE_THREADS
if (g_settings.video.threaded && !g_extern.system.hw_render_callback.context_type)
if (settings->video.threaded && !g_extern.system.hw_render_callback.context_type)
{
/* Can't do hardware rendering with threaded driver currently. */
RARCH_LOG("Starting threaded video driver ...\n");
@ -531,11 +536,11 @@ void init_video(void)
if (driver->video->set_rotation)
driver->video->set_rotation(driver->video_data,
(g_settings.video.rotation + g_extern.system.rotation) % 4);
(settings->video.rotation + g_extern.system.rotation) % 4);
if (driver->video->suppress_screensaver)
driver->video->suppress_screensaver(driver->video_data,
g_settings.ui.suspend_screensaver_enable);
settings->ui.suspend_screensaver_enable);
if (!driver->input)
init_video_input(tmp);

13
gfx/video_state_python.c
View File

@ -375,21 +375,22 @@ float py_state_get(py_state_t *handle, const char *id,
unsigned i;
float retval;
PyObject *ret = NULL;
settings_t *settings = config_get_ptr();
for (i = 0; i < MAX_USERS; i++)
{
input_push_analog_dpad(g_settings.input.binds[i],
g_settings.input.analog_dpad_mode[i]);
input_push_analog_dpad(g_settings.input.autoconf_binds[i],
g_settings.input.analog_dpad_mode[i]);
input_push_analog_dpad(settings->input.binds[i],
settings->input.analog_dpad_mode[i]);
input_push_analog_dpad(settings->input.autoconf_binds[i],
settings->input.analog_dpad_mode[i]);
}
ret = PyObject_CallMethod(handle->inst, (char*)id, (char*)"I", frame_count);
for (i = 0; i < MAX_USERS; i++)
{
input_pop_analog_dpad(g_settings.input.binds[i]);
input_pop_analog_dpad(g_settings.input.autoconf_binds[i]);
input_pop_analog_dpad(settings->input.binds[i]);
input_pop_analog_dpad(settings->input.autoconf_binds[i]);
}
if (!ret)

4
gfx/video_thread_wrapper.c
View File

@ -478,8 +478,10 @@ static bool thread_frame(void *data, const void *frame_,
if (!thr->nonblock)
{
settings_t *settings = config_get_ptr();
retro_time_t target_frame_time = (retro_time_t)
roundf(1000000LL / g_settings.video.refresh_rate);
roundf(1000000LL / settings->video.refresh_rate);
retro_time_t target = thr->last_time + target_frame_time;
/* Ideally, use absolute time, but that is only a good idea on POSIX. */

11
gfx/video_viewport.c
View File

@ -110,11 +110,13 @@ void video_viewport_set_core(void)
**/
void video_viewport_set_config(void)
{
if (g_settings.video.aspect_ratio < 0.0f)
settings_t *settings = config_get_ptr();
if (settings->video.aspect_ratio < 0.0f)
{
struct retro_game_geometry *geom = &g_extern.system.av_info.geometry;
if (geom && geom->aspect_ratio > 0.0f && g_settings.video.aspect_ratio_auto)
if (geom && geom->aspect_ratio > 0.0f && settings->video.aspect_ratio_auto)
aspectratio_lut[ASPECT_RATIO_CONFIG].value = geom->aspect_ratio;
else
{
@ -132,7 +134,7 @@ void video_viewport_set_config(void)
}
else
aspectratio_lut[ASPECT_RATIO_CONFIG].value =
g_settings.video.aspect_ratio;
settings->video.aspect_ratio;
}
/**
@ -151,11 +153,12 @@ void video_viewport_get_scaled_integer(struct video_viewport *vp,
float aspect_ratio, bool keep_aspect)
{
int padding_x = 0, padding_y = 0;
settings_t *settings = config_get_ptr();
if (!vp)
return;
if (g_settings.video.aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
if (settings->video.aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
{
const struct video_viewport *custom =
&g_extern.console.screen.viewports.custom_vp;

13
location/location_driver.c
View File

@ -112,8 +112,9 @@ 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);
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
int i = find_driver_index("location_driver", settings->location.driver);
if (i >= 0)
driver->location = (const location_driver_t*)location_driver_find_handle(i);
@ -121,7 +122,7 @@ void find_location_driver(void)
{
unsigned d;
RARCH_ERR("Couldn't find any location driver named \"%s\"\n",
g_settings.location.driver);
settings->location.driver);
RARCH_LOG_OUTPUT("Available location drivers are:\n");
for (d = 0; location_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", location_driver_find_ident(d));
@ -145,10 +146,12 @@ void find_location_driver(void)
**/
bool driver_location_start(void)
{
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (driver->location && driver->location_data && driver->location->start)
{
if (g_settings.location.allow)
if (settings->location.allow)
return driver->location->start(driver->location_data);
rarch_main_msg_queue_push("Location is explicitly disabled.\n", 1, 180, true);

42
menu/menu.c
View File

@ -42,13 +42,15 @@ bool menu_display_update_pending(void)
**/
static void draw_frame(void)
{
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_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 (!settings->menu.pause_libretro)
{
if (g_extern.main_is_init && !g_extern.libretro_dummy)
{
@ -88,7 +90,8 @@ 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();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!wrap_args)
return;
@ -101,13 +104,14 @@ static void menu_environment_get(int *argc, char *argv[],
wrap_args->state_path = *g_extern.savestate_dir ? g_extern.savestate_dir : NULL;
wrap_args->content_path = *g_extern.fullpath ? g_extern.fullpath : NULL;
if (!g_extern.has_set_libretro)
wrap_args->libretro_path = *g_settings.libretro ? g_settings.libretro : NULL;
wrap_args->libretro_path = *settings->libretro ? settings->libretro : NULL;
wrap_args->touched = true;
}
static void push_to_history_playlist(void)
{
if (!g_settings.history_list_enable)
settings_t *settings = config_get_ptr();
if (!settings->history_list_enable)
return;
if (*g_extern.fullpath)
@ -122,7 +126,7 @@ static void push_to_history_playlist(void)
content_playlist_push(g_defaults.history,
g_extern.fullpath,
g_settings.libretro,
settings->libretro,
g_extern.menu.info.library_name);
}
@ -188,7 +192,8 @@ void *menu_init(const void *data)
{
menu_handle_t *menu = NULL;
menu_ctx_driver_t *menu_ctx = (menu_ctx_driver_t*)data;
runloop_t *runloop = rarch_main_get_ptr();
runloop_t *runloop = rarch_main_get_ptr();
settings_t *settings = config_get_ptr();
if (!menu_ctx)
return NULL;
@ -198,8 +203,8 @@ void *menu_init(const void *data)
if (!(menu = (menu_handle_t*)menu_ctx->init()))
return NULL;
strlcpy(g_settings.menu.driver, menu_ctx->ident,
sizeof(g_settings.menu.driver));
strlcpy(settings->menu.driver, menu_ctx->ident,
sizeof(settings->menu.driver));
if (!(menu->menu_list = (menu_list_t*)menu_list_new()))
goto error;
@ -213,8 +218,8 @@ void *menu_init(const void *data)
if (!menu->shader)
goto error;
#endif
menu->push_start_screen = g_settings.menu_show_start_screen;
g_settings.menu_show_start_screen = false;
menu->push_start_screen = settings->menu_show_start_screen;
settings->menu_show_start_screen = false;
menu_shader_manager_init(menu);
@ -251,7 +256,8 @@ error:
**/
void menu_free_list(void *data)
{
menu_handle_t *menu = (menu_handle_t*)data;
menu_handle_t *menu = (menu_handle_t*)data;
if (!menu)
return;
@ -395,11 +401,11 @@ int menu_iterate(retro_input_t input,
{
static retro_time_t last_clock_update = 0;
int32_t ret = 0;
unsigned action = menu_input_frame(input, trigger_input);
runloop_t *runloop = rarch_main_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
unsigned action = menu_input_frame(input, trigger_input);
runloop_t *runloop = rarch_main_get_ptr();
menu_handle_t *menu = menu_driver_resolve();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
menu->cur_time = rarch_get_time_usec();
menu->dt = menu->cur_time - menu->old_time;
@ -409,7 +415,7 @@ int menu_iterate(retro_input_t input,
menu->dt = IDEAL_DT / 4;
menu->old_time = menu->cur_time;
if (menu->cur_time - last_clock_update > 1000000 && g_settings.menu.timedate_enable)
if (menu->cur_time - last_clock_update > 1000000 && settings->menu.timedate_enable)
{
runloop->frames.video.current.menu.label.is_updated = true;
last_clock_update = menu->cur_time;

7
menu/menu_driver.c
View File

@ -123,16 +123,17 @@ const char* config_get_menu_driver_options(void)
void find_menu_driver(void)
{
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
int i = find_driver_index("menu_driver", g_settings.menu.driver);
int i = find_driver_index("menu_driver", settings->menu.driver);
if (i >= 0)
driver->menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(i);
else
{
unsigned d;
RARCH_WARN("Couldn't find any menu driver named \"%s\"\n",
g_settings.menu.driver);
settings->menu.driver);
RARCH_LOG_OUTPUT("Available menu drivers are:\n");
for (d = 0; menu_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", menu_driver_find_ident(d));

16
menu/menu_entries.c
View File

@ -87,7 +87,8 @@ 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();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
settings_list_free(menu->list_settings);
menu->list_settings = (rarch_setting_t *)setting_data_new(setting_flags);
@ -103,7 +104,7 @@ int menu_entries_push_list(menu_handle_t *menu,
setting->type == ST_GROUP ||
setting->type == ST_SUB_GROUP ||
setting->type == ST_END_SUB_GROUP ||
(setting->flags & SD_FLAG_ADVANCED && !g_settings.menu.show_advanced_settings)
(setting->flags & SD_FLAG_ADVANCED && !settings->menu.show_advanced_settings)
)
continue;
@ -157,6 +158,7 @@ static int menu_entries_push_cores_list(file_list_t *list, core_info_t *info,
const char *path, bool push_databases_enable)
{
size_t i;
settings_t *settings = config_get_ptr();
if (!info->supports_no_game)
menu_entries_content_list_push(list, info, path);
@ -177,7 +179,7 @@ static int menu_entries_push_cores_list(file_list_t *list, core_info_t *info,
if (!str_list)
continue;
fill_pathname_join(db_path, g_settings.content_database,
fill_pathname_join(db_path, settings->content_database,
str_list->elems[i].data, sizeof(db_path));
strlcat(db_path, ".rdb", sizeof(db_path));
@ -198,6 +200,7 @@ int menu_entries_push_horizontal_menu_list(menu_handle_t *menu,
{
core_info_t *info = NULL;
core_info_list_t *info_list = (core_info_list_t*)g_extern.core_info;
settings_t *settings = config_get_ptr();
if (!info_list)
return -1;
@ -207,11 +210,11 @@ int menu_entries_push_horizontal_menu_list(menu_handle_t *menu,
if (!info)
return -1;
strlcpy(g_settings.libretro, info->path, sizeof(g_settings.libretro));
strlcpy(settings->libretro, info->path, sizeof(settings->libretro));
menu_list_clear(list);
menu_entries_push_cores_list(list, info, g_settings.core_assets_directory, true);
menu_entries_push_cores_list(list, info, settings->core_assets_directory, true);
menu_list_populate_generic(list, path, label, menu_type);
@ -323,6 +326,7 @@ int menu_entries_parse_list(
bool path_is_compressed, push_dir;
int device = 0;
struct string_list *str_list = NULL;
settings_t *settings = config_get_ptr();
(void)device;
@ -358,7 +362,7 @@ int menu_entries_parse_list(
str_list = compressed_file_list_new(dir,exts);
else
str_list = dir_list_new(dir,
g_settings.menu.navigation.browser.filter.supported_extensions_enable
settings->menu.navigation.browser.filter.supported_extensions_enable
? exts : NULL, true);
if (!str_list)

15
menu/menu_input.c
View File

@ -196,7 +196,8 @@ 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();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!state)
return;
@ -217,7 +218,7 @@ void menu_input_poll_bind_state(struct menu_bind_state *state)
if (joypad->poll)
joypad->poll();
for (i = 0; i < g_settings.input.max_users; i++)
for (i = 0; i < settings->input.max_users; i++)
{
for (b = 0; b < MENU_MAX_BUTTONS; b++)
state->state[i].buttons[b] = input_joypad_button_raw(joypad, i, b);
@ -243,7 +244,8 @@ 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();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!state)
return;
@ -257,7 +259,7 @@ void menu_input_poll_bind_get_rested_axes(struct menu_bind_state *state)
return;
}
for (i = 0; i < g_settings.input.max_users; i++)
for (i = 0; i < settings->input.max_users; i++)
for (a = 0; a < MENU_MAX_AXES; a++)
state->axis_state[i].rested_axes[a] =
input_joypad_axis_raw(joypad, i, a);
@ -339,18 +341,19 @@ bool menu_input_poll_find_trigger(struct menu_bind_state *state,
struct menu_bind_state *new_state)
{
unsigned i;
settings_t *settings = config_get_ptr();
if (!state || !new_state)
return false;
for (i = 0; i < g_settings.input.max_users; i++)
for (i = 0; i < settings->input.max_users; i++)
{
if (!menu_input_poll_find_trigger_pad(state, new_state, i))
continue;
/* Update the joypad mapping automatically.
* More friendly that way. */
g_settings.input.joypad_map[state->user] = i;
settings->input.joypad_map[state->user] = i;
return true;
}
return false;

47
menu/menu_shader.c
View File

@ -28,10 +28,11 @@ void menu_shader_manager_init(menu_handle_t *menu)
{
#ifdef HAVE_SHADER_MANAGER
char preset_path[PATH_MAX_LENGTH];
const char *ext;
const char *ext = NULL;
struct video_shader *shader = NULL;
config_file_t *conf = NULL;
const char *config_path = NULL;
config_file_t *conf = NULL;
const char *config_path = NULL;
settings_t *settings = config_get_ptr();
if (!menu)
return;
@ -39,7 +40,7 @@ void menu_shader_manager_init(menu_handle_t *menu)
shader = (struct video_shader*)menu->shader;
if (*g_extern.core_specific_config_path
&& g_settings.core_specific_config)
&& settings->core_specific_config)
config_path = g_extern.core_specific_config_path;
else if (*g_extern.config_path)
config_path = g_extern.config_path;
@ -63,15 +64,15 @@ void menu_shader_manager_init(menu_handle_t *menu)
strlcpy(menu->default_cgp, "menu.cgp", sizeof(menu->default_cgp));
}
ext = path_get_extension(g_settings.video.shader_path);
ext = path_get_extension(settings->video.shader_path);
if (strcmp(ext, "glslp") == 0 || strcmp(ext, "cgp") == 0)
{
conf = config_file_new(g_settings.video.shader_path);
conf = config_file_new(settings->video.shader_path);
if (conf)
{
if (video_shader_read_conf_cgp(conf, shader))
{
video_shader_resolve_relative(shader, g_settings.video.shader_path);
video_shader_resolve_relative(shader, settings->video.shader_path);
video_shader_resolve_parameters(conf, shader);
}
config_file_free(conf);
@ -79,14 +80,14 @@ void menu_shader_manager_init(menu_handle_t *menu)
}
else if (strcmp(ext, "glsl") == 0 || strcmp(ext, "cg") == 0)
{
strlcpy(shader->pass[0].source.path, g_settings.video.shader_path,
strlcpy(shader->pass[0].source.path, settings->video.shader_path,
sizeof(shader->pass[0].source.path));
shader->passes = 1;
}
else
{
const char *shader_dir = *g_settings.video.shader_dir ?
g_settings.video.shader_dir : g_settings.system_directory;
const char *shader_dir = *settings->video.shader_dir ?
settings->video.shader_dir : settings->system_directory;
fill_pathname_join(preset_path, shader_dir, "menu.glslp", sizeof(preset_path));
conf = config_file_new(preset_path);
@ -122,10 +123,11 @@ void menu_shader_manager_set_preset(struct video_shader *shader,
unsigned type, const char *preset_path)
{
#ifdef HAVE_SHADER_MANAGER
config_file_t *conf = NULL;
driver_t *driver = driver_get_ptr();
config_file_t *conf = NULL;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
g_settings.video.shader_enable = false;
settings->video.shader_enable = false;
if (!driver->video->set_shader)
return;
@ -135,9 +137,9 @@ void menu_shader_manager_set_preset(struct video_shader *shader,
/* Makes sure that we use Menu Preset shader on driver reinit.
* Only do this when the cgp actually works to avoid potential errors. */
strlcpy(g_settings.video.shader_path, preset_path ? preset_path : "",
sizeof(g_settings.video.shader_path));
g_settings.video.shader_enable = true;
strlcpy(settings->video.shader_path, preset_path ? preset_path : "",
sizeof(settings->video.shader_path));
settings->video.shader_enable = true;
if (!preset_path)
return;
@ -178,10 +180,11 @@ void menu_shader_manager_save_preset(
{
#ifdef HAVE_SHADER_MANAGER
char buffer[PATH_MAX_LENGTH], config_directory[PATH_MAX_LENGTH], preset_path[PATH_MAX_LENGTH];
unsigned d, type = RARCH_SHADER_NONE;
config_file_t *conf = NULL;
bool ret = false;
driver_t *driver = driver_get_ptr();
unsigned d, type = RARCH_SHADER_NONE;
config_file_t *conf = NULL;
bool ret = false;
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!driver->menu)
{
@ -221,8 +224,8 @@ void menu_shader_manager_save_preset(
g_extern.config_path, sizeof(config_directory));
const char *dirs[] = {
g_settings.video.shader_dir,
g_settings.menu_config_directory,
settings->video.shader_dir,
settings->menu_config_directory,
config_directory,
};

7
netplay.c
View File

@ -184,9 +184,10 @@ static bool send_chunk(netplay_t *netplay)
static bool get_self_input_state(netplay_t *netplay)
{
unsigned i;
uint32_t state = 0;
struct delta_frame *ptr = &netplay->buffer[netplay->self_ptr];
uint32_t state = 0;
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!driver->block_libretro_input && netplay->frame_count > 0)
{
@ -195,7 +196,7 @@ static bool get_self_input_state(netplay_t *netplay)
retro_input_state_t cb = netplay->cbs.state_cb;
for (i = 0; i < RARCH_FIRST_META_KEY; i++)
{
int16_t tmp = cb(g_settings.input.netplay_client_swap_input ?
int16_t tmp = cb(settings->input.netplay_client_swap_input ?
0 : !netplay->port,
RETRO_DEVICE_JOYPAD, 0, i);
state |= tmp ? 1 << i : 0;

13
record/record_driver.c
View File

@ -186,7 +186,8 @@ 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();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (!g_extern.record.enable)
return false;
@ -197,7 +198,7 @@ bool recording_init(void)
return false;
}
if (!g_settings.video.gpu_record
if (!settings->video.gpu_record
&& g_extern.system.hw_render_callback.context_type)
{
RARCH_WARN("Libretro core is hardware rendered. Must use post-shaded recording as well.\n");
@ -223,7 +224,7 @@ 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 (settings->video.gpu_record && driver->video->read_viewport)
{
struct video_viewport vp = {0};
@ -242,7 +243,7 @@ bool recording_init(void)
params.fb_width = next_pow2(vp.width);
params.fb_height = next_pow2(vp.height);
if (g_settings.video.force_aspect &&
if (settings->video.force_aspect &&
(g_extern.system.aspect_ratio > 0.0f))
params.aspect_ratio = g_extern.system.aspect_ratio;
else
@ -270,13 +271,13 @@ bool recording_init(void)
params.out_height = g_extern.record.height;
}
if (g_settings.video.force_aspect &&
if (settings->video.force_aspect &&
(g_extern.system.aspect_ratio > 0.0f))
params.aspect_ratio = g_extern.system.aspect_ratio;
else
params.aspect_ratio = (float)params.out_width / params.out_height;
if (g_settings.video.post_filter_record && g_extern.filter.filter)
if (settings->video.post_filter_record && g_extern.filter.filter)
{
unsigned max_width = 0;
unsigned max_height = 0;

23
screenshot.c
View File

@ -178,7 +178,8 @@ static bool take_screenshot_viewport(void)
uint8_t *buffer = NULL;
bool retval = false;
struct video_viewport vp = {0};
driver_t *driver = driver_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
if (driver->video && driver->video->viewport_info)
driver->video->viewport_info(driver->video_data, &vp);
@ -193,9 +194,9 @@ static bool take_screenshot_viewport(void)
if (!driver->video->read_viewport(driver->video_data, buffer))
goto done;
screenshot_dir = g_settings.screenshot_directory;
screenshot_dir = settings->screenshot_directory;
if (!*g_settings.screenshot_directory)
if (!*settings->screenshot_directory)
{
fill_pathname_basedir(screenshot_path, g_extern.basename,
sizeof(screenshot_path));
@ -222,9 +223,12 @@ static bool take_screenshot_raw(void)
unsigned width = g_extern.frame_cache.width;
unsigned height = g_extern.frame_cache.height;
int pitch = g_extern.frame_cache.pitch;
const char *screenshot_dir = g_settings.screenshot_directory;
settings_t *settings = config_get_ptr();
const char *screenshot_dir = NULL;
screenshot_dir = settings->screenshot_directory;
if (!*g_settings.screenshot_directory)
if (!*settings->screenshot_directory)
{
fill_pathname_basedir(screenshot_path, g_extern.basename,
sizeof(screenshot_path));
@ -249,14 +253,15 @@ bool take_screenshot(void)
bool viewport_read = false;
bool ret = true;
const char *msg = NULL;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
settings_t *settings = config_get_ptr();
/* No way to infer screenshot directory. */
if ((!*g_settings.screenshot_directory) && (!*g_extern.basename))
if ((!*settings->screenshot_directory) && (!*g_extern.basename))
return false;
viewport_read = (g_settings.video.gpu_screenshot ||
viewport_read = (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;