Start replacing more g_settings usages

audio/audio_monitor.c

@@ -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)
+   if (timing_skew <= settings->audio.max_timing_skew)
-      g_extern.audio_data.in_rate *= (g_settings.video.refresh_rate / info->fps);
+      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;

cheats.c

@@ -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));

content.c

@@ -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;
+   settings_t *settings = config_get_ptr();
-
+   bool ret = read_file(path, &buf, &size);
-   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 ?
+                  *settings->extraction_directory ?
-                  g_settings.extraction_directory : NULL))
+                  settings->extraction_directory : NULL))
          {
             RARCH_ERR("Failed to extract content from zipped file: %s.\n",
                   temporary_content);

driver.c

@@ -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 : 

frontend/frontend.c

@@ -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,
+      driver->frontend_ctx->exitspawn(settings->libretro,
-            sizeof(g_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);
    }
 

gfx/video_context_driver.c

@@ -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,
+      strlcpy(settings->video.context_driver, gfx_ctx_drivers[i - 1]->ident,
-            sizeof(g_settings.video.context_driver));
+            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,
+      strlcpy(settings->video.context_driver, gfx_ctx_drivers[i + 1]->ident,
-            sizeof(g_settings.video.context_driver));
+            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;
    }

gfx/video_driver.c

@@ -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();
+   runloop_t *runloop   = rarch_main_get_ptr();
-   driver_t *driver = driver_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;
+      width  = settings->video.fullscreen_x;
-      height = g_settings.video.fullscreen_y;
+      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);
+         width = roundf(base_width * settings->video.scale);
-         height = roundf(geom->base_height * g_settings.video.scale);
+         height = roundf(geom->base_height * settings->video.scale);
       }
       else
       {
-         width = roundf(geom->base_width * g_settings.video.scale);
+         width = roundf(geom->base_width   * settings->video.scale);
-         height = roundf(geom->base_height * g_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.width        = width;
-   video.height = height;
+   video.height       = height;
-   video.fullscreen = g_settings.video.fullscreen;
+   video.fullscreen   = settings->video.fullscreen;
-   video.vsync = g_settings.video.vsync && !g_extern.system.force_nonblock;
+   video.vsync        = settings->video.vsync && !g_extern.system.force_nonblock;
-   video.force_aspect = g_settings.video.force_aspect;
+   video.force_aspect = settings->video.force_aspect;
 #ifdef GEKKO
-   video.viwidth = g_settings.video.viwidth;
+   video.viwidth      = settings->video.viwidth;
-   video.vfilter = g_settings.video.vfilter;
+   video.vfilter      = settings->video.vfilter;
 #endif
-   video.smooth = g_settings.video.smooth;
+   video.smooth       = settings->video.smooth;
-   video.input_scale = scale;
+   video.input_scale  = scale;
-   video.rgb32 = g_extern.filter.filter ? 
+   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);

gfx/video_state_python.c

@@ -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],
+      input_push_analog_dpad(settings->input.binds[i],
-            g_settings.input.analog_dpad_mode[i]);
+            settings->input.analog_dpad_mode[i]);
-      input_push_analog_dpad(g_settings.input.autoconf_binds[i],
+      input_push_analog_dpad(settings->input.autoconf_binds[i],
-            g_settings.input.analog_dpad_mode[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(settings->input.binds[i]);
-      input_pop_analog_dpad(g_settings.input.autoconf_binds[i]);
+      input_pop_analog_dpad(settings->input.autoconf_binds[i]);
    }
 
    if (!ret)

gfx/video_thread_wrapper.c

@@ -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. */

gfx/video_viewport.c

@@ -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;

location/location_driver.c

@@ -112,8 +112,9 @@ const char* config_get_location_driver_options(void)
 
 void find_location_driver(void)
 {
-   driver_t *driver = driver_get_ptr();
+   driver_t *driver     = driver_get_ptr();
-   int i = find_driver_index("location_driver", g_settings.location.driver);
+   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);

menu/menu.c

@@ -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,
+   strlcpy(settings->menu.driver, menu_ctx->ident,
-         sizeof(g_settings.menu.driver));
+         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;
+   menu->push_start_screen = settings->menu_show_start_screen;
-   g_settings.menu_show_start_screen = false;
+   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);
+   unsigned action      = menu_input_frame(input, trigger_input);
-   runloop_t *runloop = rarch_main_get_ptr();
+   runloop_t *runloop   = rarch_main_get_ptr();
-
+   menu_handle_t *menu  = menu_driver_resolve();
-   menu_handle_t *menu = menu_driver_resolve();
+   driver_t *driver     = driver_get_ptr();
-   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;

menu/menu_driver.c

@@ -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));

menu/menu_entries.c

@@ -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)

menu/menu_input.c

@@ -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;

menu/menu_shader.c

@@ -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;
+   config_file_t *conf         = NULL;
-   const char *config_path = 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 ?
+      const char *shader_dir = *settings->video.shader_dir ?
-         g_settings.video.shader_dir : g_settings.system_directory;
+         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;
+   config_file_t *conf         = NULL;
-   driver_t *driver = driver_get_ptr();
+   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 : "",
+   strlcpy(settings->video.shader_path, preset_path ? preset_path : "",
-         sizeof(g_settings.video.shader_path));
+         sizeof(settings->video.shader_path));
-   g_settings.video.shader_enable = true;
+   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;
+   unsigned d, type            = RARCH_SHADER_NONE;
-   config_file_t *conf = NULL;
+   config_file_t *conf         = NULL;
-   bool ret = false;
+   bool ret                    = false;
-   driver_t *driver = driver_get_ptr();
+   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,
+      settings->video.shader_dir,
-      g_settings.menu_config_directory,
+      settings->menu_config_directory,
       config_directory,
    };
 

netplay.c

@@ -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;

record/record_driver.c

@@ -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;

screenshot.c

@@ -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();
+   runloop_t *runloop   = rarch_main_get_ptr();
-   driver_t *driver   = driver_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;