input: add gamepad support through SDL2

The code is very basic:

- only handles gamepads, could be extended for generic joysticks in the
  future.
- only has button mappings for controllers natively supported by SDL2.
  I heard more can be added through env vars, there's also ways to load
  mappings from text files, but I'd rather not go there yet. Common ones
  like Dualshock are supported natively.
- analog buttons (TRIGGER and AXIS) are mapped to discrete buttons using an
  activation threshold.
- only supports one gamepad at a time. the feature is intented to use
  gamepads as evolved remote controls, not play multiplayer games in mpv :)

5 files changed, 346 insertions, 0 deletions

diff --git a/input/input.c b/input/input.c
index 8a14d862b3..32ee75b4cf 100644
--- a/input/input.c
+++ b/input/input.c
@@ -173,6 +173,7 @@ struct input_opts {
     int ar_rate;
     int use_alt_gr;
     int use_appleremote;
+    int use_gamepad;
     int use_media_keys;
     int default_bindings;
     int enable_mouse_movements;
@@ -199,6 +200,9 @@ const struct m_sub_options input_config = {
 #if HAVE_COCOA
         OPT_FLAG("input-appleremote", use_appleremote, 0),
 #endif
+#if HAVE_SDL2_GAMEPAD
+        OPT_FLAG("input-gamepad", use_gamepad, 0),
+#endif
         OPT_FLAG("window-dragging", allow_win_drag, 0),
         OPT_REPLACED("input-x11-keyboard", "input-vo-keyboard"),
         {0}
@@ -215,6 +219,9 @@ const struct m_sub_options input_config = {
 #if HAVE_COCOA
         .use_appleremote = 1,
 #endif
+#if HAVE_SDL2_GAMEPAD
+        .use_gamepad = 1,
+#endif
         .default_bindings = 1,
         .vo_key_input = 1,
         .allow_win_drag = 1,
@@ -1377,6 +1384,12 @@ void mp_input_load_config(struct input_ctx *ictx)
     talloc_free(ifile);
 #endif
 
+#if HAVE_SDL2_GAMEPAD
+    if (ictx->opts->use_gamepad) {
+        mp_input_sdl_gamepad_add(ictx);
+    }
+#endif
+
     input_unlock(ictx);
 }
 
diff --git a/input/input.h b/input/input.h
index 3dfc053bd0..f62a50bdca 100644
--- a/input/input.h
+++ b/input/input.h
@@ -210,6 +210,8 @@ void mp_input_set_repeat_info(struct input_ctx *ictx, int rate, int delay);
 
 void mp_input_pipe_add(struct input_ctx *ictx, const char *filename);
 
+void mp_input_sdl_gamepad_add(struct input_ctx *ictx);
+
 struct mp_ipc_ctx;
 struct mp_client_api;
 
diff --git a/input/keycodes.c b/input/keycodes.c
index 81371e20bf..a03f07e59a 100644
--- a/input/keycodes.c
+++ b/input/keycodes.c
@@ -117,6 +117,32 @@ static const struct key_name key_names[] = {
   { MP_AR_VDOWN,        "AR_VDOWN" },
   { MP_AR_VDOWN_HOLD,   "AR_VDOWN_HOLD" },
 
+  { MP_KEY_GAMEPAD_ACTION_DOWN, "GAMEPAD_ACTION_DOWN" },
+  { MP_KEY_GAMEPAD_ACTION_RIGHT, "GAMEPAD_ACTION_RIGHT" },
+  { MP_KEY_GAMEPAD_ACTION_LEFT, "GAMEPAD_ACTION_LEFT" },
+  { MP_KEY_GAMEPAD_ACTION_UP, "GAMEPAD_ACTION_UP" },
+  { MP_KEY_GAMEPAD_BACK, "GAMEPAD_BACK" },
+  { MP_KEY_GAMEPAD_MENU, "GAMEPAD_MENU" },
+  { MP_KEY_GAMEPAD_START, "GAMEPAD_START" },
+  { MP_KEY_GAMEPAD_LEFT_SHOULDER, "GAMEPAD_LEFT_SHOULDER" },
+  { MP_KEY_GAMEPAD_RIGHT_SHOULDER, "GAMEPAD_RIGHT_SHOULDER" },
+  { MP_KEY_GAMEPAD_LEFT_TRIGGER, "GAMEPAD_LEFT_TRIGGER" },
+  { MP_KEY_GAMEPAD_RIGHT_TRIGGER, "GAMEPAD_RIGHT_TRIGGER" },
+  { MP_KEY_GAMEPAD_LEFT_STICK, "GAMEPAD_LEFT_STICK" },
+  { MP_KEY_GAMEPAD_RIGHT_STICK, "GAMEPAD_RIGHT_STICK" },
+  { MP_KEY_GAMEPAD_DPAD_UP, "GAMEPAD_DPAD_UP" },
+  { MP_KEY_GAMEPAD_DPAD_DOWN, "GAMEPAD_DPAD_DOWN" },
+  { MP_KEY_GAMEPAD_DPAD_LEFT, "GAMEPAD_DPAD_LEFT" },
+  { MP_KEY_GAMEPAD_DPAD_RIGHT, "GAMEPAD_DPAD_RIGHT" },
+  { MP_KEY_GAMEPAD_LEFT_STICK_UP, "GAMEPAD_LEFT_STICK_UP" },
+  { MP_KEY_GAMEPAD_LEFT_STICK_DOWN, "GAMEPAD_LEFT_STICK_DOWN" },
+  { MP_KEY_GAMEPAD_LEFT_STICK_LEFT, "GAMEPAD_LEFT_STICK_LEFT" },
+  { MP_KEY_GAMEPAD_LEFT_STICK_RIGHT, "GAMEPAD_LEFT_STICK_RIGHT" },
+  { MP_KEY_GAMEPAD_RIGHT_STICK_UP, "GAMEPAD_RIGHT_STICK_UP" },
+  { MP_KEY_GAMEPAD_RIGHT_STICK_DOWN, "GAMEPAD_RIGHT_STICK_DOWN" },
+  { MP_KEY_GAMEPAD_RIGHT_STICK_LEFT, "GAMEPAD_RIGHT_STICK_LEFT" },
+  { MP_KEY_GAMEPAD_RIGHT_STICK_RIGHT, "GAMEPAD_RIGHT_STICK_RIGHT" },
+
   { MP_KEY_POWER,       "POWER" },
   { MP_KEY_MENU,        "MENU" },
   { MP_KEY_PLAY,        "PLAY" },
diff --git a/input/keycodes.h b/input/keycodes.h
index 604fee53dc..12b45e528a 100644
--- a/input/keycodes.h
+++ b/input/keycodes.h
@@ -154,6 +154,34 @@
 #define MP_AR_VDOWN       (MP_AR_BASE + 12)
 #define MP_AR_VDOWN_HOLD  (MP_AR_BASE + 13)
 
+/* game controller keys */
+#define MP_KEY_GAMEPAD                    (MP_KEY_BASE+0xF0)
+#define MP_KEY_GAMEPAD_ACTION_DOWN        (MP_KEY_GAMEPAD+0)
+#define MP_KEY_GAMEPAD_ACTION_RIGHT       (MP_KEY_GAMEPAD+1)
+#define MP_KEY_GAMEPAD_ACTION_LEFT        (MP_KEY_GAMEPAD+2)
+#define MP_KEY_GAMEPAD_ACTION_UP          (MP_KEY_GAMEPAD+3)
+#define MP_KEY_GAMEPAD_BACK               (MP_KEY_GAMEPAD+4)
+#define MP_KEY_GAMEPAD_MENU               (MP_KEY_GAMEPAD+5)
+#define MP_KEY_GAMEPAD_START              (MP_KEY_GAMEPAD+6)
+#define MP_KEY_GAMEPAD_LEFT_SHOULDER      (MP_KEY_GAMEPAD+7)
+#define MP_KEY_GAMEPAD_RIGHT_SHOULDER     (MP_KEY_GAMEPAD+8)
+#define MP_KEY_GAMEPAD_LEFT_TRIGGER       (MP_KEY_GAMEPAD+9)
+#define MP_KEY_GAMEPAD_RIGHT_TRIGGER      (MP_KEY_GAMEPAD+10)
+#define MP_KEY_GAMEPAD_LEFT_STICK         (MP_KEY_GAMEPAD+11)
+#define MP_KEY_GAMEPAD_RIGHT_STICK        (MP_KEY_GAMEPAD+12)
+#define MP_KEY_GAMEPAD_DPAD_UP            (MP_KEY_GAMEPAD+13)
+#define MP_KEY_GAMEPAD_DPAD_DOWN          (MP_KEY_GAMEPAD+14)
+#define MP_KEY_GAMEPAD_DPAD_LEFT          (MP_KEY_GAMEPAD+15)
+#define MP_KEY_GAMEPAD_DPAD_RIGHT         (MP_KEY_GAMEPAD+16)
+#define MP_KEY_GAMEPAD_LEFT_STICK_UP      (MP_KEY_GAMEPAD+17)
+#define MP_KEY_GAMEPAD_LEFT_STICK_DOWN    (MP_KEY_GAMEPAD+18)
+#define MP_KEY_GAMEPAD_LEFT_STICK_LEFT    (MP_KEY_GAMEPAD+19)
+#define MP_KEY_GAMEPAD_LEFT_STICK_RIGHT   (MP_KEY_GAMEPAD+20)
+#define MP_KEY_GAMEPAD_RIGHT_STICK_UP     (MP_KEY_GAMEPAD+21)
+#define MP_KEY_GAMEPAD_RIGHT_STICK_DOWN   (MP_KEY_GAMEPAD+22)
+#define MP_KEY_GAMEPAD_RIGHT_STICK_LEFT   (MP_KEY_GAMEPAD+23)
+#define MP_KEY_GAMEPAD_RIGHT_STICK_RIGHT  (MP_KEY_GAMEPAD+24)
+
 // Reserved area. Can be used for keys that have no explicit names assigned,
 // but should be mappable by the user anyway.
 #define MP_KEY_UNKNOWN_RESERVED_START (MP_KEY_BASE+0x10000)
diff --git a/input/sdl_gamepad.c b/input/sdl_gamepad.c
new file mode 100644
index 0000000000..23997bfa07
--- /dev/null
+++ b/input/sdl_gamepad.c
@@ -0,0 +1,277 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <SDL.h>
+#include <stdbool.h>
+#include <pthread.h>
+#include "common/common.h"
+#include "common/msg.h"
+#include "input.h"
+#include "input/keycodes.h"
+
+struct gamepad_priv {
+    SDL_GameController *controller;
+};
+
+static Uint32 gamepad_cancel_wakeup;
+
+static void initalize_events()
+{
+    gamepad_cancel_wakeup = SDL_RegisterEvents(1);
+}
+
+static pthread_once_t events_initialized = PTHREAD_ONCE_INIT;
+
+#define INVALID_KEY -1
+
+static const int button_map[][2] = {
+    { SDL_CONTROLLER_BUTTON_A, MP_KEY_GAMEPAD_ACTION_DOWN },
+    { SDL_CONTROLLER_BUTTON_B, MP_KEY_GAMEPAD_ACTION_RIGHT },
+    { SDL_CONTROLLER_BUTTON_X, MP_KEY_GAMEPAD_ACTION_LEFT },
+    { SDL_CONTROLLER_BUTTON_Y,  MP_KEY_GAMEPAD_ACTION_UP },
+    { SDL_CONTROLLER_BUTTON_BACK, MP_KEY_GAMEPAD_BACK },
+    { SDL_CONTROLLER_BUTTON_GUIDE, MP_KEY_GAMEPAD_MENU },
+    { SDL_CONTROLLER_BUTTON_START, MP_KEY_GAMEPAD_START },
+    { SDL_CONTROLLER_BUTTON_LEFTSTICK, MP_KEY_GAMEPAD_LEFT_STICK },
+    { SDL_CONTROLLER_BUTTON_RIGHTSTICK, MP_KEY_GAMEPAD_RIGHT_STICK },
+    { SDL_CONTROLLER_BUTTON_LEFTSHOULDER, MP_KEY_GAMEPAD_LEFT_SHOULDER },
+    { SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, MP_KEY_GAMEPAD_RIGHT_SHOULDER },
+    { SDL_CONTROLLER_BUTTON_DPAD_UP, MP_KEY_GAMEPAD_DPAD_UP },
+    { SDL_CONTROLLER_BUTTON_DPAD_DOWN, MP_KEY_GAMEPAD_DPAD_DOWN },
+    { SDL_CONTROLLER_BUTTON_DPAD_LEFT, MP_KEY_GAMEPAD_DPAD_LEFT },
+    { SDL_CONTROLLER_BUTTON_DPAD_RIGHT, MP_KEY_GAMEPAD_DPAD_RIGHT },
+};
+
+static const int analog_map[][5] = {
+    // 0 -> sdl enum
+    // 1 -> negative state
+    // 2 -> neutral-negative state
+    // 3 -> neutral-positive state
+    // 4 -> positive state
+    { SDL_CONTROLLER_AXIS_LEFTX,
+        MP_KEY_GAMEPAD_LEFT_STICK_LEFT | MP_KEY_STATE_DOWN,
+        MP_KEY_GAMEPAD_LEFT_STICK_LEFT | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_LEFT_STICK_RIGHT | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_LEFT_STICK_RIGHT | MP_KEY_STATE_DOWN },
+
+    { SDL_CONTROLLER_AXIS_LEFTY,
+        MP_KEY_GAMEPAD_LEFT_STICK_UP | MP_KEY_STATE_DOWN,
+        MP_KEY_GAMEPAD_LEFT_STICK_UP | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_LEFT_STICK_DOWN | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_LEFT_STICK_DOWN | MP_KEY_STATE_DOWN },
+
+    { SDL_CONTROLLER_AXIS_RIGHTX,
+        MP_KEY_GAMEPAD_RIGHT_STICK_LEFT | MP_KEY_STATE_DOWN,
+        MP_KEY_GAMEPAD_RIGHT_STICK_LEFT | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_RIGHT_STICK_RIGHT | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_RIGHT_STICK_RIGHT | MP_KEY_STATE_DOWN },
+
+    { SDL_CONTROLLER_AXIS_RIGHTY,
+        MP_KEY_GAMEPAD_RIGHT_STICK_UP | MP_KEY_STATE_DOWN,
+        MP_KEY_GAMEPAD_RIGHT_STICK_UP | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_RIGHT_STICK_DOWN | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_RIGHT_STICK_DOWN | MP_KEY_STATE_DOWN },
+
+    { SDL_CONTROLLER_AXIS_TRIGGERLEFT,
+        INVALID_KEY,
+        INVALID_KEY,
+        MP_KEY_GAMEPAD_LEFT_TRIGGER | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_LEFT_TRIGGER | MP_KEY_STATE_DOWN },
+
+    { SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
+        INVALID_KEY,
+        INVALID_KEY,
+        MP_KEY_GAMEPAD_RIGHT_TRIGGER | MP_KEY_STATE_UP,
+        MP_KEY_GAMEPAD_RIGHT_TRIGGER | MP_KEY_STATE_DOWN },
+};
+
+static int lookup_button_mp_key(int sdl_key)
+{
+    for (int i = 0; i < MP_ARRAY_SIZE(button_map); i++) {
+        if (button_map[i][0] == sdl_key) {
+            return button_map[i][1];
+        }
+    }
+    return INVALID_KEY;
+}
+
+static int lookup_analog_mp_key(int sdl_key, int16_t value)
+{
+    const int sdl_axis_max = 32767;
+    const int negative = 1;
+    const int negative_neutral = 2;
+    const int positive_neutral = 3;
+    const int positive = 4;
+
+    const float activation_threshold = sdl_axis_max * 0.33;
+    const float noise_threshold = sdl_axis_max * 0.06;
+
+    // sometimes SDL just keeps shitting out low values around 0 that mess
+    // with key repeating code
+    if (value < noise_threshold && value > -noise_threshold) {
+        return INVALID_KEY;
+    }
+
+    int state = value > 0 ? positive_neutral : negative_neutral;
+
+    if (value >= sdl_axis_max - activation_threshold) {
+        state = positive;
+    }
+
+    if (value <= activation_threshold - sdl_axis_max) {
+        state = negative;
+    }
+
+    for (int i = 0; i < MP_ARRAY_SIZE(analog_map); i++) {
+        if (analog_map[i][0] == sdl_key) {
+            return analog_map[i][state];
+        }
+    }
+
+    return INVALID_KEY;
+}
+
+
+static void request_cancel(struct mp_input_src *src)
+{
+    MP_VERBOSE(src, "exiting...\n");
+    SDL_Event event = { .type = gamepad_cancel_wakeup };
+    SDL_PushEvent(&event);
+}
+
+static void uninit(struct mp_input_src *src)
+{
+    MP_VERBOSE(src, "exited.\n");
+}
+
+#define GUID_LEN 33
+
+static void add_gamepad(struct mp_input_src *src, int id)
+{
+    struct gamepad_priv *p = src->priv;
+
+    if (p->controller) {
+        MP_WARN(src, "can't add more than one controller\n");
+        return;
+    }
+
+    if (SDL_IsGameController(id)) {
+        SDL_GameController *controller = SDL_GameControllerOpen(id);
+
+        if (controller) {
+            const char *name = SDL_GameControllerName(controller);
+            MP_INFO(src, "added controller: %s\n", name);
+            p->controller = controller;
+            return;
+        }
+    }
+}
+
+static void remove_gamepad(struct mp_input_src *src, int id)
+{
+    struct gamepad_priv *p = src->priv;
+    SDL_GameController *controller = p->controller;
+    SDL_Joystick* j = SDL_GameControllerGetJoystick(controller);
+    SDL_JoystickID jid = SDL_JoystickInstanceID(j);
+
+    if (controller && jid == id) {
+        const char *name = SDL_GameControllerName(controller);
+        MP_INFO(src, "removed controller: %s\n", name);
+        SDL_GameControllerClose(controller);
+        p->controller = NULL;
+    }
+}
+
+static void read_gamepad_thread(struct mp_input_src *src, void *param)
+{
+    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER)) {
+        MP_ERR(src, "SDL_Init failed\n");
+        mp_input_src_init_done(src);
+        return;
+    };
+
+    pthread_once(&events_initialized, initalize_events);
+
+    if (gamepad_cancel_wakeup == (Uint32)-1) {
+        MP_ERR(src, "Can't register SDL custom events\n");
+        mp_input_src_init_done(src);
+        return;
+    }
+
+    struct gamepad_priv *p =src->priv = talloc_zero(src, struct gamepad_priv);
+    src->cancel = request_cancel;
+    src->uninit = uninit;
+
+    mp_input_src_init_done(src);
+
+    SDL_Event ev;
+
+    while (SDL_WaitEvent(&ev) != 0) {
+        if (ev.type == gamepad_cancel_wakeup) {
+            break;
+        }
+
+        switch (ev.type) {
+            case SDL_CONTROLLERDEVICEADDED: {
+                add_gamepad(src, ev.cdevice.which);
+                continue;
+            }
+            case SDL_CONTROLLERDEVICEREMOVED: {
+                remove_gamepad(src, ev.cdevice.which);
+                continue;
+            }
+            case SDL_CONTROLLERBUTTONDOWN: {
+                const int key = lookup_button_mp_key(ev.cbutton.button);
+                if (key != INVALID_KEY) {
+                    mp_input_put_key(src->input_ctx, key | MP_KEY_STATE_DOWN);
+                }
+                continue;
+            }
+            case SDL_CONTROLLERBUTTONUP: {
+                const int key = lookup_button_mp_key(ev.cbutton.button);
+                if (key != INVALID_KEY) {
+                    mp_input_put_key(src->input_ctx, key | MP_KEY_STATE_UP);
+                }
+                continue;
+            }
+            case SDL_CONTROLLERAXISMOTION: {
+                const int key =
+                    lookup_analog_mp_key(ev.caxis.axis, ev.caxis.value);
+                if (key != INVALID_KEY) {
+                    mp_input_put_key(src->input_ctx, key);
+                }
+                continue;
+            }
+
+        }
+    }
+
+    if (p->controller) {
+        SDL_Joystick* j = SDL_GameControllerGetJoystick(p->controller);
+        SDL_JoystickID jid = SDL_JoystickInstanceID(j);
+        remove_gamepad(src, jid);
+    }
+
+    // must be called on the same thread of SDL_InitSubSystem, so uninit
+    // callback can't be used for this
+    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
+}
+
+void mp_input_sdl_gamepad_add(struct input_ctx *ictx)
+{
+    mp_input_add_thread_src(ictx, NULL, read_gamepad_thread);
+}