in_sdl.c

   1 /*
   2  * (C) Gražvydas "notaz" Ignotas, 2012
   3  *
   4  * This work is licensed under the terms of any of these licenses
   5  * (at your option):
   6  *  - GNU GPL, version 2 or later.
   7  *  - GNU LGPL, version 2.1 or later.
   8  *  - MAME license.
   9  * See the COPYING file in the top-level directory.
  10  */
  11
  12 #include <stdio.h>
  13 #include <SDL.h>
  14 #include "input.h"
  15 #include "in_sdl.h"
  16
  17 #define IN_SDL_PREFIX "sdl:"
  18 /* should be machine word for best performace */
  19 typedef unsigned long keybits_t;
  20 #define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8)
  21
  22 struct in_sdl_state {
  23         const in_drv_t *drv;
  24         SDL_Joystick *joy;
  25         int joy_id;
  26         int axis_keydown[2];
  27 #ifdef SDL_REDRAW_EVT
  28         int rdraw;
  29 #endif
  30         keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
  31         // emulator keys should always be processed immediately lest one is lost
  32         keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1];
  33 };
  34
  35 static void (*ext_event_handler)(void *event);
  36
  37 static const char * const in_sdl_keys[SDLK_LAST] = {
  38         [SDLK_BACKSPACE] = "backspace",
  39         [SDLK_TAB] = "tab",
  40         [SDLK_CLEAR] = "clear",
  41         [SDLK_RETURN] = "return",
  42         [SDLK_PAUSE] = "pause",
  43         [SDLK_ESCAPE] = "escape",
  44         [SDLK_SPACE] = "space",
  45         [SDLK_EXCLAIM]  = "!",
  46         [SDLK_QUOTEDBL]  = "\"",
  47         [SDLK_HASH]  = "#",
  48         [SDLK_DOLLAR]  = "$",
  49         [SDLK_AMPERSAND]  = "&",
  50         [SDLK_QUOTE] = "'",
  51         [SDLK_LEFTPAREN] = "(",
  52         [SDLK_RIGHTPAREN] = ")",
  53         [SDLK_ASTERISK] = "*",
  54         [SDLK_PLUS] = "+",
  55         [SDLK_COMMA] = ",",
  56         [SDLK_MINUS] = "-",
  57         [SDLK_PERIOD] = ".",
  58         [SDLK_SLASH] = "/",
  59         [SDLK_0] = "0",
  60         [SDLK_1] = "1",
  61         [SDLK_2] = "2",
  62         [SDLK_3] = "3",
  63         [SDLK_4] = "4",
  64         [SDLK_5] = "5",
  65         [SDLK_6] = "6",
  66         [SDLK_7] = "7",
  67         [SDLK_8] = "8",
  68         [SDLK_9] = "9",
  69         [SDLK_COLON] = ":",
  70         [SDLK_SEMICOLON] = ";",
  71         [SDLK_LESS] = "<",
  72         [SDLK_EQUALS] = "=",
  73         [SDLK_GREATER] = ">",
  74         [SDLK_QUESTION] = "?",
  75         [SDLK_AT] = "@",
  76         [SDLK_LEFTBRACKET] = "[",
  77         [SDLK_BACKSLASH] = "\\",
  78         [SDLK_RIGHTBRACKET] = "]",
  79         [SDLK_CARET] = "^",
  80         [SDLK_UNDERSCORE] = "_",
  81         [SDLK_BACKQUOTE] = "`",
  82         [SDLK_a] = "a",
  83         [SDLK_b] = "b",
  84         [SDLK_c] = "c",
  85         [SDLK_d] = "d",
  86         [SDLK_e] = "e",
  87         [SDLK_f] = "f",
  88         [SDLK_g] = "g",
  89         [SDLK_h] = "h",
  90         [SDLK_i] = "i",
  91         [SDLK_j] = "j",
  92         [SDLK_k] = "k",
  93         [SDLK_l] = "l",
  94         [SDLK_m] = "m",
  95         [SDLK_n] = "n",
  96         [SDLK_o] = "o",
  97         [SDLK_p] = "p",
  98         [SDLK_q] = "q",
  99         [SDLK_r] = "r",
 100         [SDLK_s] = "s",
 101         [SDLK_t] = "t",
 102         [SDLK_u] = "u",
 103         [SDLK_v] = "v",
 104         [SDLK_w] = "w",
 105         [SDLK_x] = "x",
 106         [SDLK_y] = "y",
 107         [SDLK_z] = "z",
 108         [SDLK_DELETE] = "delete",
 109
 110         [SDLK_KP0] = "[0]",
 111         [SDLK_KP1] = "[1]",
 112         [SDLK_KP2] = "[2]",
 113         [SDLK_KP3] = "[3]",
 114         [SDLK_KP4] = "[4]",
 115         [SDLK_KP5] = "[5]",
 116         [SDLK_KP6] = "[6]",
 117         [SDLK_KP7] = "[7]",
 118         [SDLK_KP8] = "[8]",
 119         [SDLK_KP9] = "[9]",
 120         [SDLK_KP_PERIOD] = "[.]",
 121         [SDLK_KP_DIVIDE] = "[/]",
 122         [SDLK_KP_MULTIPLY] = "[*]",
 123         [SDLK_KP_MINUS] = "[-]",
 124         [SDLK_KP_PLUS] = "[+]",
 125         [SDLK_KP_ENTER] = "enter",
 126         [SDLK_KP_EQUALS] = "equals",
 127
 128         [SDLK_UP] = "up",
 129         [SDLK_DOWN] = "down",
 130         [SDLK_RIGHT] = "right",
 131         [SDLK_LEFT] = "left",
 132         [SDLK_INSERT] = "insert",
 133         [SDLK_HOME] = "home",
 134         [SDLK_END] = "end",
 135         [SDLK_PAGEUP] = "page up",
 136         [SDLK_PAGEDOWN] = "page down",
 137
 138         [SDLK_F1] = "f1",
 139         [SDLK_F2] = "f2",
 140         [SDLK_F3] = "f3",
 141         [SDLK_F4] = "f4",
 142         [SDLK_F5] = "f5",
 143         [SDLK_F6] = "f6",
 144         [SDLK_F7] = "f7",
 145         [SDLK_F8] = "f8",
 146         [SDLK_F9] = "f9",
 147         [SDLK_F10] = "f10",
 148         [SDLK_F11] = "f11",
 149         [SDLK_F12] = "f12",
 150         [SDLK_F13] = "f13",
 151         [SDLK_F14] = "f14",
 152         [SDLK_F15] = "f15",
 153
 154         [SDLK_NUMLOCK] = "numlock",
 155         [SDLK_CAPSLOCK] = "caps lock",
 156         [SDLK_SCROLLOCK] = "scroll lock",
 157         [SDLK_RSHIFT] = "right shift",
 158         [SDLK_LSHIFT] = "left shift",
 159         [SDLK_RCTRL] = "right ctrl",
 160         [SDLK_LCTRL] = "left ctrl",
 161         [SDLK_RALT] = "right alt",
 162         [SDLK_LALT] = "left alt",
 163         [SDLK_RMETA] = "right meta",
 164         [SDLK_LMETA] = "left meta",
 165         [SDLK_LSUPER] = "left super",   /* "Windows" keys */
 166         [SDLK_RSUPER] = "right super",
 167         [SDLK_MODE] = "alt gr",
 168         [SDLK_COMPOSE] = "compose",
 169 };
 170
 171 static void in_sdl_probe(const in_drv_t *drv)
 172 {
 173         const struct in_pdata *pdata = drv->pdata;
 174         const char * const * key_names = in_sdl_keys;
 175         struct in_sdl_state *state;
 176         SDL_Joystick *joy;
 177         int i, joycount;
 178         char name[256];
 179
 180         if (pdata->key_names)
 181                 key_names = pdata->key_names;
 182
 183         state = calloc(1, sizeof(*state));
 184         if (state == NULL) {
 185                 fprintf(stderr, "in_sdl: OOM\n");
 186                 return;
 187         }
 188
 189         state->drv = drv;
 190         in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
 191                 key_names, 0);
 192
 193         /* joysticks go here too */
 194         SDL_InitSubSystem(SDL_INIT_JOYSTICK);
 195
 196         joycount = SDL_NumJoysticks();
 197         for (i = 0; i < joycount; i++) {
 198                 joy = SDL_JoystickOpen(i);
 199                 if (joy == NULL)
 200                         continue;
 201
 202                 state = calloc(1, sizeof(*state));
 203                 if (state == NULL) {
 204                         fprintf(stderr, "in_sdl: OOM\n");
 205                         break;
 206                 }
 207                 state->joy = joy;
 208                 state->joy_id = i;
 209                 state->drv = drv;
 210
 211                 snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
 212                 in_register(name, -1, state, SDLK_LAST, key_names, 0);
 213         }
 214
 215         if (joycount > 0)
 216                 SDL_JoystickEventState(SDL_ENABLE);
 217 }
 218
 219 static void in_sdl_free(void *drv_data)
 220 {
 221         struct in_sdl_state *state = drv_data;
 222
 223         if (state != NULL) {
 224                 if (state->joy != NULL)
 225                         SDL_JoystickClose(state->joy);
 226                 free(state);
 227         }
 228 }
 229
 230 static const char * const *
 231 in_sdl_get_key_names(const in_drv_t *drv, int *count)
 232 {
 233         const struct in_pdata *pdata = drv->pdata;
 234         *count = SDLK_LAST;
 235
 236         if (pdata->key_names)
 237                 return pdata->key_names;
 238         return in_sdl_keys;
 239 }
 240
 241 /* could use SDL_GetKeyState, but this gives better packing */
 242 static void update_keystate(keybits_t *keystate, int sym, int is_down)
 243 {
 244         keybits_t *ks_word, mask;
 245
 246         mask = 1;
 247         mask <<= sym & (KEYBITS_WORD_BITS - 1);
 248         ks_word = keystate + sym / KEYBITS_WORD_BITS;
 249         if (is_down)
 250                 *ks_word |= mask;
 251         else
 252                 *ks_word &= ~mask;
 253 }
 254
 255 static int get_keystate(keybits_t *keystate, int sym)
 256 {
 257         keybits_t *ks_word, mask;
 258
 259         mask = 1;
 260         mask <<= sym & (KEYBITS_WORD_BITS - 1);
 261         ks_word = keystate + sym / KEYBITS_WORD_BITS;
 262         return !!(*ks_word & mask);
 263 }
 264
 265 static int handle_event(struct in_sdl_state *state, SDL_Event *event,
 266         int *kc_out, int *down_out, int *emu_out)
 267 {
 268         int emu;
 269
 270         if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
 271                 return -1;
 272
 273         emu = get_keystate(state->emu_keys, event->key.keysym.sym);
 274         update_keystate(state->keystate, event->key.keysym.sym,
 275                 event->type == SDL_KEYDOWN);
 276         if (kc_out != NULL)
 277                 *kc_out = event->key.keysym.sym;
 278         if (down_out != NULL)
 279                 *down_out = event->type == SDL_KEYDOWN;
 280         if (emu_out != NULL)
 281                 *emu_out = emu;
 282
 283         return 1;
 284 }
 285
 286 static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
 287         int *kc_out, int *down_out, int *emu_out)
 288 {
 289         int kc = -1, down = 0, emu = 0, ret = 0;
 290
 291         /* TODO: remaining axis */
 292         switch (event->type) {
 293         case SDL_JOYAXISMOTION:
 294                 if (event->jaxis.which != state->joy_id)
 295                         return -2;
 296                 if (event->jaxis.axis > 1)
 297                         break;
 298                 if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) {
 299                         kc = state->axis_keydown[event->jaxis.axis];
 300                         state->axis_keydown[event->jaxis.axis] = 0;
 301                         ret = 1;
 302                 }
 303                 else if (event->jaxis.value < -16384) {
 304                         kc = state->axis_keydown[event->jaxis.axis];
 305                         if (kc) {
 306                                 emu |= get_keystate(state->emu_keys, kc);
 307                                 update_keystate(state->keystate, kc, 0);
 308                         }
 309                         kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
 310                         state->axis_keydown[event->jaxis.axis] = kc;
 311                         down = 1;
 312                         ret = 1;
 313                 }
 314                 else if (event->jaxis.value > 16384) {
 315                         kc = state->axis_keydown[event->jaxis.axis];
 316                         if (kc) {
 317                                 emu |= get_keystate(state->emu_keys, kc);
 318                                 update_keystate(state->keystate, kc, 0);
 319                         }
 320                         kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
 321                         state->axis_keydown[event->jaxis.axis] = kc;
 322                         down = 1;
 323                         ret = 1;
 324                 }
 325                 break;
 326
 327         case SDL_JOYBUTTONDOWN:
 328         case SDL_JOYBUTTONUP:
 329                 if (event->jbutton.which != state->joy_id)
 330                         return -2;
 331                 kc = (int)event->jbutton.button + SDLK_WORLD_0;
 332                 down = event->jbutton.state == SDL_PRESSED;
 333                 ret = 1;
 334                 break;
 335         default:
 336                 return -1;
 337         }
 338
 339         if (ret) {
 340                 emu |= get_keystate(state->emu_keys, kc);
 341                 update_keystate(state->keystate, kc, down);
 342         }
 343         if (kc_out != NULL)
 344                 *kc_out = kc;
 345         if (down_out != NULL)
 346                 *down_out = down;
 347         if (emu_out != 0)
 348                 *emu_out = emu;
 349
 350         return ret;
 351 }
 352
 353 #define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \
 354                     | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK)
 355
 356 static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
 357 {
 358         SDL_Event events[4];
 359         Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
 360         int count, maxcount, is_emukey = 0;
 361         int i, ret, retval = 0;
 362         int num_events, num_peeped_events;
 363         SDL_Event *event;
 364
 365 #ifdef SDL_REDRAW_EVT
 366         if (state->rdraw) {
 367                 if (one_kc != NULL)
 368                         *one_kc = SDLK_UNKNOWN;
 369                 if (one_down != NULL)
 370                         *one_down = 0;
 371                 state->rdraw = 0;
 372                 return 1;
 373         }
 374 #endif
 375         maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);
 376
 377         SDL_PumpEvents();
 378
 379         num_events = SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, mask);
 380
 381         for (num_peeped_events = 0; num_peeped_events < num_events; num_peeped_events += count) {
 382                 count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
 383                 if (count <= 0)
 384                         break;
 385                 for (i = 0; i < count; i++) {
 386                         event = &events[i];
 387                         if (state->joy) {
 388                                 ret = handle_joy_event(state,
 389                                         event, one_kc, one_down, &is_emukey);
 390                         } else {
 391                                 ret = handle_event(state,
 392                                         event, one_kc, one_down, &is_emukey);
 393                         }
 394                         if (ret < 0) {
 395                                 switch (ret) {
 396                                         case -2:
 397                                                 SDL_PushEvent(event);
 398                                                 break;
 399                                         default:
 400                                                 if (ext_event_handler != NULL)
 401                                                         ext_event_handler(event);
 402                                                 break;
 403                                 }
 404 #ifdef SDL_REDRAW_EVT
 405                                 if (ret != -2 && event->type == SDL_VIDEORESIZE) {
 406                                         if (one_kc != NULL)
 407                                                 *one_kc = SDLK_UNKNOWN;
 408                                         if (one_down != NULL)
 409                                                 *one_down = 1;
 410                                         state->rdraw = 1;
 411                                         is_emukey = 1, ret = 1;
 412                                 } else
 413                                         continue;
 414 #endif
 415                         }
 416
 417                         retval |= ret;
 418                         if ((is_emukey || one_kc != NULL) && retval)
 419                         {
 420                                 // don't lose events other devices might want to handle
 421                                 if (++i < count)
 422                                         SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask);
 423                                 goto out;
 424                         }
 425                 }
 426         }
 427
 428 out:
 429         return retval;
 430 }
 431
 432 static int in_sdl_update(void *drv_data, const int *binds, int *result)
 433 {
 434         struct in_sdl_state *state = drv_data;
 435         keybits_t mask;
 436         int i, sym, bit, b;
 437
 438         collect_events(state, NULL, NULL);
 439
 440         for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
 441                 mask = state->keystate[i];
 442                 if (mask == 0)
 443                         continue;
 444                 for (bit = 0; mask != 0; bit++, mask >>= 1) {
 445                         if ((mask & 1) == 0)
 446                                 continue;
 447                         sym = i * KEYBITS_WORD_BITS + bit;
 448
 449                         for (b = 0; b < IN_BINDTYPE_COUNT; b++)
 450                                 result[b] |= binds[IN_BIND_OFFS(sym, b)];
 451                 }
 452         }
 453
 454         return 0;
 455 }
 456
 457 static int in_sdl_update_keycode(void *drv_data, int *is_down)
 458 {
 459         struct in_sdl_state *state = drv_data;
 460         int ret_kc = -1, ret_down = 0;
 461
 462         collect_events(state, &ret_kc, &ret_down);
 463
 464         if (is_down != NULL)
 465                 *is_down = ret_down;
 466
 467         return ret_kc;
 468 }
 469
 470 static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
 471 {
 472         struct in_sdl_state *state = drv_data;
 473         const struct in_pdata *pdata = state->drv->pdata;
 474         const char * const * key_names = in_sdl_keys;
 475         const struct menu_keymap *map;
 476         int map_len;
 477         int ret = 0;
 478         int i;
 479
 480         if (pdata->key_names)
 481                 key_names = pdata->key_names;
 482
 483         if (state->joy) {
 484                 map = pdata->joy_map;
 485                 map_len = pdata->jmap_size;
 486         } else {
 487                 map = pdata->key_map;
 488                 map_len = pdata->kmap_size;
 489         }
 490
 491         if (keycode < 0)
 492         {
 493                 /* menu -> kc */
 494                 keycode = -keycode;
 495                 for (i = 0; i < map_len; i++)
 496                         if (map[i].pbtn == keycode)
 497                                 return map[i].key;
 498         }
 499         else
 500         {
 501 #ifdef SDL_REDRAW_EVT
 502                 if (keycode == SDLK_UNKNOWN)
 503                         ret = PBTN_RDRAW;
 504                 else
 505 #endif
 506                 for (i = 0; i < map_len; i++) {
 507                         if (map[i].key == keycode) {
 508                                 ret = map[i].pbtn;
 509                                 break;
 510                         }
 511                 }
 512
 513                 if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
 514                     key_names[keycode] != NULL && key_names[keycode][1] == 0)
 515                 {
 516                         ret |= PBTN_CHAR;
 517                         *charcode = key_names[keycode][0];
 518                 }
 519         }
 520
 521         return ret;
 522 }
 523
 524 static int in_sdl_clean_binds(void *drv_data, int *binds, int *def_finds)
 525 {
 526         struct in_sdl_state *state = drv_data;
 527         int i, t, cnt = 0;
 528
 529         memset(state->emu_keys, 0, sizeof(state->emu_keys));
 530         for (t = 0; t < IN_BINDTYPE_COUNT; t++)
 531                 for (i = 0; i < SDLK_LAST; i++)
 532                         if (binds[IN_BIND_OFFS(i, t)]) {
 533                                 if (t == IN_BINDTYPE_EMU)
 534                                         update_keystate(state->emu_keys, i, 1);
 535                                 cnt ++;
 536                         }
 537
 538         return cnt;
 539 }
 540
 541 static const in_drv_t in_sdl_drv = {
 542         .prefix         = IN_SDL_PREFIX,
 543         .probe          = in_sdl_probe,
 544         .free           = in_sdl_free,
 545         .get_key_names  = in_sdl_get_key_names,
 546         .update         = in_sdl_update,
 547         .update_keycode = in_sdl_update_keycode,
 548         .menu_translate = in_sdl_menu_translate,
 549         .clean_binds    = in_sdl_clean_binds,
 550 };
 551
 552 int in_sdl_init(const struct in_pdata *pdata, void (*handler)(void *event))
 553 {
 554         if (!pdata) {
 555                 fprintf(stderr, "in_sdl: Missing input platform data\n");
 556                 return -1;
 557         }
 558
 559         in_register_driver(&in_sdl_drv, pdata->defbinds, pdata);
 560         ext_event_handler = handler;
 561         return 0;
 562 }