Updates pt. 5

input/drivers/android_input.c

@@ -304,13 +304,14 @@ error:
 static void *android_input_init(void)
 {
    int32_t sdk;
+   settings_t *settings = config_get_ptr();
    android_input_t *android = (android_input_t*)calloc(1, sizeof(*android));
 
    if (!android)
       return NULL;
 
    android->pads_connected = 0;
-   android->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   android->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    frontend_android_get_version_sdk(&sdk);
 
@@ -441,8 +442,9 @@ static void handle_hotplug(android_input_t *android,
    char device_name[256], name_buf[256];
    name_buf[0] = device_name[0] = 0;
    int vendorId = 0, productId = 0;
+   settings_t *settings = config_get_ptr();
 
-   if (!g_settings.input.autodetect_enable)
+   if (!settings->input.autodetect_enable)
       return;
 
    if (*port > MAX_PADS)
@@ -595,8 +597,8 @@ static void handle_hotplug(android_input_t *android,
 
    if (name_buf[0] != '\0')
    {
-      strlcpy(g_settings.input.device_names[*port],
+      strlcpy(settings->input.device_names[*port],
-            name_buf, sizeof(g_settings.input.device_names[*port]));
+            name_buf, sizeof(settings->input.device_names[*port]));
 
       input_config_autoconfigure_joypad(*port, name_buf,
             vendorId, productId,
@@ -744,13 +746,15 @@ static int16_t android_input_state(void *data,
 
 static bool android_input_key_pressed(void *data, int key)
 {
-   driver_t *driver = driver_get_ptr();
    android_input_t *android = (android_input_t*)data;
+   driver_t *driver = driver_get_ptr();
+   settings_t *settings = config_get_ptr();
+
    if (!android)
       return false;
    return ((g_extern.lifecycle_state | driver->overlay_state.buttons)
          & (1ULL << key)) || input_joypad_pressed(android->joypad,
-         0, g_settings.input.binds[0], key);
+         0, settings->input.binds[0], key);
 }
 
 static void android_input_free_input(void *data)

input/drivers/apple_input.c

@@ -231,15 +231,14 @@ static int16_t apple_input_is_pressed(apple_input_data_t *apple, unsigned port_n
 
 static void *apple_input_init(void)
 {
-   apple_input_data_t *apple = NULL;
+   settings_t *settings = config_get_ptr();
-    
+   apple_input_data_t *apple = (apple_input_data_t*)calloc(1, sizeof(*apple));
-   apple = (apple_input_data_t*)calloc(1, sizeof(*apple));
    if (!apple)
       return NULL;
     
    input_keymaps_init_keyboard_lut(rarch_key_map_apple_hid);
 
-   apple->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   apple->joypad = input_joypad_init_driver(settings->input.joypad_driver);
     
    return apple;
 }
@@ -365,9 +364,10 @@ static int16_t apple_input_state(void *data,
 static bool apple_input_bind_button_pressed(void *data, int key)
 {
    apple_input_data_t *apple = (apple_input_data_t*)data;
+   settings_t *settings = config_get_ptr();
    if (apple && apple->joypad)
-      return apple_input_is_pressed(apple, 0, g_settings.input.binds[0], key) ||
+      return apple_input_is_pressed(apple, 0, settings->input.binds[0], key) ||
-         input_joypad_pressed(apple->joypad, 0, g_settings.input.binds[0], key);
+         input_joypad_pressed(apple->joypad, 0, settings->input.binds[0], key);
    return false;
 }
 

input/drivers/dinput.c

@@ -112,7 +112,8 @@ static bool dinput_init_context(void)
 static void *dinput_init(void)
 {
    struct dinput_input *di = NULL;
-   driver_t *driver = driver_get_ptr();
+   driver_t *driver     = driver_get_ptr();
+   settings_t *settings = config_get_ptr();
 
    if (!dinput_init_context())
    {
@@ -166,7 +167,7 @@ static void *dinput_init(void)
    }
 
    input_keymaps_init_keyboard_lut(rarch_key_map_dinput);
-   di->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   di->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    return di;
 }
@@ -271,8 +272,9 @@ static int16_t dinput_pressed_analog(struct dinput_input *di,
 
 static bool dinput_key_pressed(void *data, int key)
 {
+   settings_t *settings = config_get_ptr();
    return dinput_is_pressed((struct dinput_input*)data,
-         g_settings.input.binds[0], 0, key);
+         settings->input.binds[0], 0, key);
 }
 
 static int16_t dinput_lightgun_state(struct dinput_input *di, unsigned id)
@@ -398,6 +400,7 @@ static int16_t dinput_input_state(void *data,
 {
    int16_t ret;
    struct dinput_input *di = (struct dinput_input*)data;
+   settings_t *settings    = config_get_ptr();
 
    switch (device)
    {
@@ -411,7 +414,7 @@ static int16_t dinput_input_state(void *data,
          ret = dinput_pressed_analog(di, binds[port], idx, id);
          if (!ret)
             ret = input_joypad_analog(di->joypad, port,
-                  idx, id, g_settings.input.binds[port]);
+                  idx, id, settings->input.binds[port]);
          return ret;
 
       case RETRO_DEVICE_MOUSE:
@@ -524,6 +527,7 @@ extern "C"
 bool dinput_handle_message(void *dinput, UINT message, WPARAM wParam, LPARAM lParam)
 {
    struct dinput_input *di = (struct dinput_input *)dinput;
+   settings_t *settings    = config_get_ptr();
    /* WM_POINTERDOWN   : Arrives for each new touch event 
     *                    with a new ID - add to list.
     * WM_POINTERUP     : Arrives once the pointer is no 
@@ -568,7 +572,7 @@ bool dinput_handle_message(void *dinput, UINT message, WPARAM wParam, LPARAM lPa
       {
          if (di->joypad)
             di->joypad->destroy();
-         di->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+         di->joypad = input_joypad_init_driver(settings->input.joypad_driver);
          break;
       }
       case WM_MOUSEWHEEL:
@@ -588,6 +592,7 @@ bool dinput_handle_message(void *dinput, UINT message, WPARAM wParam, LPARAM lPa
           }
           break;
    }
+
    return false;
 }
 
@@ -691,6 +696,7 @@ bool g_xinput_block_pads;
 static void dinput_joypad_destroy(void)
 {
    unsigned i;
+   settings_t *settings = config_get_ptr();
 
    for (i = 0; i < MAX_USERS; i++)
    {
@@ -702,7 +708,7 @@ static void dinput_joypad_destroy(void)
       
       free(g_pads[i].joy_name);
       g_pads[i].joy_name = NULL;
-      *g_settings.input.device_names[i] = '\0';
+      *settings->input.device_names[i] = '\0';
    }
 
    g_joypad_cnt = 0;
@@ -811,7 +817,8 @@ static BOOL CALLBACK enum_joypad_cb(const DIDEVICEINSTANCE *inst, void *p)
 {
    bool is_xinput_pad;
    LPDIRECTINPUTDEVICE8 *pad = NULL;
-   driver_t *driver = driver_get_ptr();
+   driver_t *driver     = driver_get_ptr();
+   settings_t *settings = config_get_ptr();
 
    (void)p;
 
@@ -858,9 +865,9 @@ static BOOL CALLBACK enum_joypad_cb(const DIDEVICEINSTANCE *inst, void *p)
    if (!is_xinput_pad)
 #endif
    {
-      strlcpy(g_settings.input.device_names[g_joypad_cnt],
+      strlcpy(settings->input.device_names[g_joypad_cnt],
             dinput_joypad_name(g_joypad_cnt),
-            sizeof(g_settings.input.device_names[g_joypad_cnt]));
+            sizeof(settings->input.device_names[g_joypad_cnt]));
       /* TODO - implement VID/PID? */
       input_config_autoconfigure_joypad(g_joypad_cnt,
             dinput_joypad_name(g_joypad_cnt), 0, 0,

input/drivers/gx_input.c

@@ -70,11 +70,12 @@ static void gx_input_free_input(void *data)
 
 static void *gx_input_init(void)
 {
+   settings_t *settings = config_get_ptr();
    gx_input_t *gx = (gx_input_t*)calloc(1, sizeof(*gx));
    if (!gx)
       return NULL;
 
-   gx->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   gx->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    return gx;
 }
@@ -89,9 +90,10 @@ static void gx_input_poll(void *data)
 
 static bool gx_input_key_pressed(void *data, int key)
 {
+   settings_t *settings = config_get_ptr();
    gx_input_t *gx = (gx_input_t*)data;
    return (g_extern.lifecycle_state & (1ULL << key)) || 
-      input_joypad_pressed(gx->joypad, 0, g_settings.input.binds[0], key);
+      input_joypad_pressed(gx->joypad, 0, settings->input.binds[0], key);
 }
 
 static uint64_t gx_input_get_capabilities(void *data)

input/drivers/linuxraw_input.c

@@ -60,7 +60,8 @@ static void *linuxraw_input_init(void)
 {
    struct sigaction sa;
    linuxraw_input_t *linuxraw = NULL;
-   driver_t *driver = driver_get_ptr();
+   driver_t *driver     = driver_get_ptr();
+   settings_t *settings = config_get_ptr();
 
    /* Only work on terminals. */
    if (!isatty(0))
@@ -116,7 +117,7 @@ static void *linuxraw_input_init(void)
 
    atexit(linuxraw_resetKbmd);
 
-   linuxraw->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   linuxraw->joypad = input_joypad_init_driver(settings->input.joypad_driver);
    input_keymaps_init_keyboard_lut(rarch_key_map_linux);
 
    /* We need to disable use of stdin command interface if 
@@ -165,8 +166,10 @@ static int16_t linuxraw_analog_pressed(linuxraw_input_t *linuxraw,
 static bool linuxraw_bind_button_pressed(void *data, int key)
 {
    linuxraw_input_t *linuxraw = (linuxraw_input_t*)data;
-   return linuxraw_is_pressed(linuxraw, g_settings.input.binds[0], key) ||
+   settings_t *settings       = config_get_ptr();
-      input_joypad_pressed(linuxraw->joypad, 0, g_settings.input.binds[0], key);
+
+   return linuxraw_is_pressed(linuxraw, settings->input.binds[0], key) ||
+      input_joypad_pressed(linuxraw->joypad, 0, settings->input.binds[0], key);
 }
 
 static int16_t linuxraw_input_state(void *data,

input/drivers/ps3_input.c

@@ -156,11 +156,12 @@ static void ps3_input_free_input(void *data)
 
 static void* ps3_input_init(void)
 {
+   settings_t *settings = config_get_ptr();
    ps3_input_t *ps3 = (ps3_input_t*)calloc(1, sizeof(*ps3));
    if (!ps3)
       return NULL;
 
-   ps3->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   ps3->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    if (ps3->joypad)
       ps3->joypad->init();
@@ -174,10 +175,12 @@ static void* ps3_input_init(void)
 static bool ps3_input_key_pressed(void *data, int key)
 {
    ps3_input_t *ps3 = (ps3_input_t*)data;
-   if (ps3)
+   settings_t *settings = config_get_ptr();
-      return (g_extern.lifecycle_state & (1ULL << key)) || 
+
-         input_joypad_pressed(ps3->joypad, 0, g_settings.input.binds[0], key);
+   if (!ps3)
-   return false;
+      return false;
+   return (g_extern.lifecycle_state & (1ULL << key)) || 
+      input_joypad_pressed(ps3->joypad, 0, settings->input.binds[0], key);
 }
 
 static uint64_t ps3_input_get_capabilities(void *data)

input/drivers/psp_input.c

@@ -82,20 +82,22 @@ static void psp_input_free_input(void *data)
 
 static void* psp_input_initialize(void)
 {
+   settings_t *settings = config_get_ptr();
    psp_input_t *psp = (psp_input_t*)calloc(1, sizeof(*psp));
    if (!psp)
       return NULL;
    
-   psp->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);   
+   psp->joypad = input_joypad_init_driver(settings->input.joypad_driver);   
 
    return psp;
 }
 
 static bool psp_input_key_pressed(void *data, int key)
 {
+   settings_t *settings = config_get_ptr();
    psp_input_t *psp = (psp_input_t*)data;
    return (g_extern.lifecycle_state & (1ULL << key)) || 
-      input_joypad_pressed(psp->joypad, 0, g_settings.input.binds[0], key);
+      input_joypad_pressed(psp->joypad, 0, settings->input.binds[0], key);
 }
 
 static uint64_t psp_input_get_capabilities(void *data)

input/drivers/qnx_input.c

@@ -92,8 +92,9 @@ static void process_gamepad_event(void *data,
    int i;
    screen_device_t device;
    input_device_t* controller = NULL;
-
+   settings_t *settings = config_get_ptr();
    qnx_input_t *qnx = (qnx_input_t*)data;
+
    (void)type;
 
    screen_get_event_property_pv(screen_event,
@@ -133,7 +134,7 @@ static void process_gamepad_event(void *data,
     * TODO: Am I missing something? Is there a better way? */
    if((controller->port == 0) && 
          (controller->buttons & 
-          g_settings.input.binds[0][RARCH_MENU_TOGGLE].joykey))
+          settings->input.binds[0][RARCH_MENU_TOGGLE].joykey))
       g_extern.lifecycle_state ^= (1ULL << RARCH_MENU_TOGGLE);
 }
 
@@ -273,6 +274,7 @@ static void qnx_input_autodetect_gamepad(void *data,
 {
    char name_buf[256];
    qnx_input_t *qnx = (qnx_input_t*)data;
+   settings_t *settings = config_get_ptr();
 
    if (!qnx)
       return;
@@ -303,8 +305,8 @@ static void qnx_input_autodetect_gamepad(void *data,
 
    if (name_buf[0] != '\0')
    {
-      strlcpy(g_settings.input.device_names[port],
+      strlcpy(settings->input.device_names[port],
-            name_buf, sizeof(g_settings.input.device_names[port]));
+            name_buf, sizeof(settings->input.device_names[port]));
 
       input_config_autoconfigure_joypad(port, name_buf,
             controller->vid, controller->vid,
@@ -322,6 +324,7 @@ static void process_keyboard_event(void *data,
    input_device_t* controller = NULL;
    int i, b, sym, modifiers, flags, scan, cap;
    qnx_input_t *qnx = (qnx_input_t*)data;
+   settings_t *settings = config_get_ptr();
 
    (void)type;
 
@@ -375,7 +378,7 @@ static void process_keyboard_event(void *data,
    for (b = 0; b < RARCH_FIRST_CUSTOM_BIND; ++b)
    {
       if ((unsigned int)
-            g_settings.input.binds[controller->port][b].joykey 
+            settings->input.binds[controller->port][b].joykey 
             == (unsigned int)(sym & 0xFF))
       {
          if (flags & KEY_DOWN)
@@ -390,7 +393,7 @@ static void process_keyboard_event(void *data,
 
    /* TODO: Am I missing something? Is there a better way? */
    if((controller->port == 0) && ((unsigned int)
-            g_settings.input.binds[0][RARCH_MENU_TOGGLE].joykey 
+            settings->input.binds[0][RARCH_MENU_TOGGLE].joykey 
             == (unsigned int)(sym&0xFF)))
    {
       if (flags & KEY_DOWN)
@@ -638,6 +641,7 @@ static void handle_navigator_event(void *data, bps_event_t *event)
 static void *qnx_input_init(void)
 {
    int i;
+   settings_t *settings = config_get_ptr();
    qnx_input_t *qnx = (qnx_input_t*)calloc(1, sizeof(*qnx));
    if (!qnx)
       return NULL;
@@ -648,7 +652,7 @@ static void *qnx_input_init(void)
       qnx->touch_map[i] = -1;
    }
 
-   qnx->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   qnx->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    for (i = 0; i < MAX_PADS; ++i)
    {
@@ -770,12 +774,13 @@ static int16_t qnx_input_state(void *data,
       unsigned port, unsigned device, unsigned idx, unsigned id)
 {
    qnx_input_t *qnx = (qnx_input_t*)data;
+   settings_t *settings = config_get_ptr();
 
    switch (device)
    {
       case RETRO_DEVICE_JOYPAD:
          return input_joypad_pressed(qnx->joypad, port,
-               (unsigned int)g_settings.input.binds[port], id);
+               (unsigned int)settings->input.binds[port], id);
       case RETRO_DEVICE_ANALOG:
          return qnx_analog_input_state(qnx, port, idx, id);
       case RARCH_DEVICE_POINTER_SCREEN:
@@ -790,8 +795,10 @@ static int16_t qnx_input_state(void *data,
 static bool qnx_input_key_pressed(void *data, int key)
 {
    qnx_input_t *qnx = (qnx_input_t*)data;
+   settings_t *settings = config_get_ptr();
+
    return ((g_extern.lifecycle_state | driver.overlay_state.buttons ) & (1ULL << key) ||
-         input_joypad_pressed(qnx->joypad, 0, g_settings.input.binds[0], key));
+         input_joypad_pressed(qnx->joypad, 0, settings->input.binds[0], key));
 }
 
 static void qnx_input_free_input(void *data)

input/drivers/rwebinput_input.c

@@ -79,7 +79,8 @@ static bool rwebinput_is_pressed(rwebinput_input_t *rwebinput, const struct retr
 static bool rwebinput_bind_button_pressed(void *data, int key)
 {
    rwebinput_input_t *rwebinput = (rwebinput_input_t*)data;
-   return rwebinput_is_pressed(rwebinput, g_settings.input.binds[0], key);
+   settings_t *settings = config_get_ptr();
+   return rwebinput_is_pressed(rwebinput, settings->input.binds[0], key);
 }
 
 static int16_t rwebinput_mouse_state(rwebinput_input_t *rwebinput, unsigned id)

input/drivers/sdl_input.c

@@ -41,11 +41,12 @@ typedef struct sdl_input
 static void *sdl_input_init(void)
 {
    input_keymaps_init_keyboard_lut(rarch_key_map_sdl);
+   settings_t *settings = config_get_ptr();
    sdl_input_t *sdl = (sdl_input_t*)calloc(1, sizeof(*sdl));
    if (!sdl)
       return NULL;
 
-   sdl->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   sdl->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    RARCH_LOG("[SDL]: Input driver initialized.\n");
    return sdl;
@@ -101,7 +102,8 @@ static int16_t sdl_analog_pressed(sdl_input_t *sdl, const struct retro_keybind *
 
 static bool sdl_bind_button_pressed(void *data, int key)
 {
-   const struct retro_keybind *binds = g_settings.input.binds[0];
+   settings_t *settings = config_get_ptr();
+   const struct retro_keybind *binds = settings->input.binds[0];
    if (key >= 0 && key < RARCH_BIND_LIST_END)
       return sdl_is_pressed((sdl_input_t*)data, 0, binds, key);
    return false;

input/drivers/udev_input.c

@@ -557,8 +557,10 @@ static int16_t udev_input_state(void *data, const struct retro_keybind **binds,
 static bool udev_input_bind_button_pressed(void *data, int key)
 {
    udev_input_t *udev = (udev_input_t*)data;
-   return udev_input_is_pressed(udev, g_settings.input.binds[0], key) ||
+   settings_t *settings = config_get_ptr();
-      input_joypad_pressed(udev->joypad, 0, g_settings.input.binds[0], key);
+
+   return udev_input_is_pressed(udev, settings->input.binds[0], key) ||
+      input_joypad_pressed(udev->joypad, 0, settings->input.binds[0], key);
 }
 
 static void udev_input_free(void *data)
@@ -705,6 +707,7 @@ static void disable_terminal_input(void)
 
 static void *udev_input_init(void)
 {
+   settings_t *settings = config_get_ptr();
    udev_input_t *udev = (udev_input_t*)calloc(1, sizeof(*udev));
 
    if (!udev)
@@ -743,9 +746,9 @@ static void *udev_input_init(void)
 
       rule.rules = "evdev";
 
-      if (*g_settings.input.keyboard_layout)
+      if (*settings->input.keyboard_layout)
       {
-         list = string_split(g_settings.input.keyboard_layout, ":");
+         list = string_split(settings->input.keyboard_layout, ":");
          if (list && list->size >= 2)
             rule.variant = list->elems[1].data;
          if (list && list->size >= 1)
@@ -814,7 +817,7 @@ static void *udev_input_init(void)
    if (!udev->num_devices)
       RARCH_WARN("[udev]: Couldn't open any keyboard, mouse or touchpad. Are permissions set correctly for /dev/input/event*?\n");
 
-   udev->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   udev->joypad = input_joypad_init_driver(settings->input.joypad_driver);
    input_keymaps_init_keyboard_lut(rarch_key_map_linux);
 
    disable_terminal_input();

input/drivers/x11_input.c

@@ -47,7 +47,9 @@ typedef struct x11_input
 
 static void *x_input_init(void)
 {
-   driver_t *driver = driver_get_ptr();
+   driver_t *driver     = driver_get_ptr();
+   settings_t *settings = config_get_ptr();
+
    if (driver->display_type != RARCH_DISPLAY_X11)
    {
       RARCH_ERR("Currently active window is not an X11 window. Cannot use this driver.\n");
@@ -62,7 +64,7 @@ static void *x_input_init(void)
    x11->display = (Display*)driver->video_display;
    x11->win     = (Window)driver->video_window;
 
-   x11->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   x11->joypad = input_joypad_init_driver(settings->input.joypad_driver);
    input_keymaps_init_keyboard_lut(rarch_key_map_x11);
 
    return x11;
@@ -116,10 +118,11 @@ static int16_t x_pressed_analog(x11_input_t *x11,
 static bool x_bind_button_pressed(void *data, int key)
 {
    x11_input_t *x11 = (x11_input_t*)data;
+   settings_t *settings = config_get_ptr();
    if (!x11)
       return false;
-   return x_is_pressed(x11, g_settings.input.binds[0], key) ||
+   return x_is_pressed(x11, settings->input.binds[0], key) ||
-      input_joypad_pressed(x11->joypad, 0, g_settings.input.binds[0], key);
+      input_joypad_pressed(x11->joypad, 0, settings->input.binds[0], key);
 }
 
 static int16_t x_mouse_state(x11_input_t *x11, unsigned id)

input/drivers/xdk_xinput_input.c

@@ -75,11 +75,12 @@ static void xdk_input_free_input(void *data)
 
 static void *xdk_input_init(void)
 {
-   xdk_input_t *xdk = (xdk_input_t*)calloc(1, sizeof(*xdk));
+   settings_t *settings = config_get_ptr();
+   xdk_input_t *xdk     = (xdk_input_t*)calloc(1, sizeof(*xdk));
    if (!xdk)
       return NULL;
 
-   xdk->joypad = input_joypad_init_driver(g_settings.input.joypad_driver);
+   xdk->joypad = input_joypad_init_driver(settings->input.joypad_driver);
 
    return xdk;
 }
@@ -87,8 +88,9 @@ static void *xdk_input_init(void)
 static bool xdk_input_key_pressed(void *data, int key)
 {
    xdk_input_t *xdk = (xdk_input_t*)data;
+   settings_t *settings = config_get_ptr();
    return (g_extern.lifecycle_state & (1ULL << key)) ||
-      input_joypad_pressed(xdk->joypad, 0, g_settings.input.binds[0], key);
+      input_joypad_pressed(xdk->joypad, 0, settings->input.binds[0], key);
 }
 
 static uint64_t xdk_input_get_capabilities(void *data)