src/haptic/windows/SDL_xinputhaptic.c
author Ryan C. Gordon <icculus@icculus.org>
Mon, 21 May 2018 12:00:21 -0400
changeset 11994 8e094f91ddab
parent 11811 5d94cb6b24d3
child 12503 806492103856
permissions -rw-r--r--
thread: fixed compiler warnings on non-Linux systems that use pthread.

(static function rtkit_setpriority was unused, moved it in with rest of
__LINUX__ section.)
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../../SDL_internal.h"
    22 
    23 #include "SDL_error.h"
    24 #include "SDL_haptic.h"
    25 #include "../SDL_syshaptic.h"
    26 
    27 #if SDL_HAPTIC_XINPUT
    28 
    29 #include "SDL_assert.h"
    30 #include "SDL_hints.h"
    31 #include "SDL_timer.h"
    32 #include "SDL_windowshaptic_c.h"
    33 #include "SDL_xinputhaptic_c.h"
    34 #include "../../core/windows/SDL_xinput.h"
    35 #include "../../joystick/windows/SDL_windowsjoystick_c.h"
    36 #include "../../thread/SDL_systhread.h"
    37 
    38 /*
    39  * Internal stuff.
    40  */
    41 static SDL_bool loaded_xinput = SDL_FALSE;
    42 
    43 
    44 int
    45 SDL_XINPUT_HapticInit(void)
    46 {
    47     if (SDL_GetHintBoolean(SDL_HINT_XINPUT_ENABLED, SDL_TRUE)) {
    48         loaded_xinput = (WIN_LoadXInputDLL() == 0);
    49     }
    50 
    51     if (loaded_xinput) {
    52         DWORD i;
    53         for (i = 0; i < XUSER_MAX_COUNT; i++) {
    54             SDL_XINPUT_MaybeAddDevice(i);
    55         }
    56     }
    57     return 0;
    58 }
    59 
    60 int
    61 SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
    62 {
    63     const Uint8 userid = (Uint8)dwUserid;
    64     SDL_hapticlist_item *item;
    65     XINPUT_VIBRATION state;
    66 
    67     if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
    68         return -1;
    69     }
    70 
    71     /* Make sure we don't already have it */
    72     for (item = SDL_hapticlist; item; item = item->next) {
    73         if (item->bXInputHaptic && item->userid == userid) {
    74             return -1;  /* Already added */
    75         }
    76     }
    77 
    78     SDL_zero(state);
    79     if (XINPUTSETSTATE(dwUserid, &state) != ERROR_SUCCESS) {
    80         return -1;  /* no force feedback on this device. */
    81     }
    82 
    83     item = (SDL_hapticlist_item *)SDL_malloc(sizeof(SDL_hapticlist_item));
    84     if (item == NULL) {
    85         return SDL_OutOfMemory();
    86     }
    87 
    88     SDL_zerop(item);
    89 
    90     /* !!! FIXME: I'm not bothering to query for a real name right now (can we even?) */
    91     {
    92         char buf[64];
    93         SDL_snprintf(buf, sizeof(buf), "XInput Controller #%u", (unsigned int)(userid + 1));
    94         item->name = SDL_strdup(buf);
    95     }
    96 
    97     if (!item->name) {
    98         SDL_free(item);
    99         return -1;
   100     }
   101 
   102     /* Copy the instance over, useful for creating devices. */
   103     item->bXInputHaptic = SDL_TRUE;
   104     item->userid = userid;
   105 
   106     return SDL_SYS_AddHapticDevice(item);
   107 }
   108 
   109 int
   110 SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
   111 {
   112     const Uint8 userid = (Uint8)dwUserid;
   113     SDL_hapticlist_item *item;
   114     SDL_hapticlist_item *prev = NULL;
   115 
   116     if ((!loaded_xinput) || (dwUserid >= XUSER_MAX_COUNT)) {
   117         return -1;
   118     }
   119 
   120     for (item = SDL_hapticlist; item != NULL; item = item->next) {
   121         if (item->bXInputHaptic && item->userid == userid) {
   122             /* found it, remove it. */
   123             return SDL_SYS_RemoveHapticDevice(prev, item);
   124         }
   125         prev = item;
   126     }
   127     return -1;
   128 }
   129 
   130 /* !!! FIXME: this is a hack, remove this later. */
   131 /* Since XInput doesn't offer a way to vibrate for X time, we hook into
   132  *  SDL_PumpEvents() to check if it's time to stop vibrating with some
   133  *  frequency.
   134  * In practice, this works for 99% of use cases. But in an ideal world,
   135  *  we do this in a separate thread so that:
   136  *    - we aren't bound to when the app chooses to pump the event queue.
   137  *    - we aren't adding more polling to the event queue
   138  *    - we can emulate all the haptic effects correctly (start on a delay,
   139  *      mix multiple effects, etc).
   140  *
   141  * Mostly, this is here to get rumbling to work, and all the other features
   142  *  are absent in the XInput path for now.  :(
   143  */
   144 static int SDLCALL
   145 SDL_RunXInputHaptic(void *arg)
   146 {
   147     struct haptic_hwdata *hwdata = (struct haptic_hwdata *) arg;
   148 
   149     while (!SDL_AtomicGet(&hwdata->stopThread)) {
   150         SDL_Delay(50);
   151         SDL_LockMutex(hwdata->mutex);
   152         /* If we're currently running and need to stop... */
   153         if (hwdata->stopTicks) {
   154             if ((hwdata->stopTicks != SDL_HAPTIC_INFINITY) && SDL_TICKS_PASSED(SDL_GetTicks(), hwdata->stopTicks)) {
   155                 XINPUT_VIBRATION vibration = { 0, 0 };
   156                 hwdata->stopTicks = 0;
   157                 XINPUTSETSTATE(hwdata->userid, &vibration);
   158             }
   159         }
   160         SDL_UnlockMutex(hwdata->mutex);
   161     }
   162 
   163     return 0;
   164 }
   165 
   166 static int
   167 SDL_XINPUT_HapticOpenFromUserIndex(SDL_Haptic *haptic, const Uint8 userid)
   168 {
   169     char threadName[32];
   170     XINPUT_VIBRATION vibration = { 0, 0 };  /* stop any current vibration */
   171     XINPUTSETSTATE(userid, &vibration);
   172 
   173     haptic->supported = SDL_HAPTIC_LEFTRIGHT;
   174 
   175     haptic->neffects = 1;
   176     haptic->nplaying = 1;
   177 
   178     /* Prepare effects memory. */
   179     haptic->effects = (struct haptic_effect *)
   180         SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
   181     if (haptic->effects == NULL) {
   182         return SDL_OutOfMemory();
   183     }
   184     /* Clear the memory */
   185     SDL_memset(haptic->effects, 0,
   186         sizeof(struct haptic_effect) * haptic->neffects);
   187 
   188     haptic->hwdata = (struct haptic_hwdata *) SDL_malloc(sizeof(*haptic->hwdata));
   189     if (haptic->hwdata == NULL) {
   190         SDL_free(haptic->effects);
   191         haptic->effects = NULL;
   192         return SDL_OutOfMemory();
   193     }
   194     SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
   195 
   196     haptic->hwdata->bXInputHaptic = 1;
   197     haptic->hwdata->userid = userid;
   198 
   199     haptic->hwdata->mutex = SDL_CreateMutex();
   200     if (haptic->hwdata->mutex == NULL) {
   201         SDL_free(haptic->effects);
   202         SDL_free(haptic->hwdata);
   203         haptic->effects = NULL;
   204         return SDL_SetError("Couldn't create XInput haptic mutex");
   205     }
   206 
   207     SDL_snprintf(threadName, sizeof(threadName), "SDLXInputDev%d", (int)userid);
   208     haptic->hwdata->thread = SDL_CreateThreadInternal(SDL_RunXInputHaptic, threadName, 64 * 1024, haptic->hwdata);
   209 
   210     if (haptic->hwdata->thread == NULL) {
   211         SDL_DestroyMutex(haptic->hwdata->mutex);
   212         SDL_free(haptic->effects);
   213         SDL_free(haptic->hwdata);
   214         haptic->effects = NULL;
   215         return SDL_SetError("Couldn't create XInput haptic thread");
   216     }
   217 
   218     return 0;
   219 }
   220 
   221 int
   222 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
   223 {
   224     return SDL_XINPUT_HapticOpenFromUserIndex(haptic, item->userid);
   225 }
   226 
   227 int
   228 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
   229 {
   230     return (haptic->hwdata->userid == joystick->hwdata->userid);
   231 }
   232 
   233 int
   234 SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
   235 {
   236     SDL_hapticlist_item *item;
   237     int index = 0;
   238 
   239     /* Since it comes from a joystick we have to try to match it with a haptic device on our haptic list. */
   240     for (item = SDL_hapticlist; item != NULL; item = item->next) {
   241         if (item->bXInputHaptic && item->userid == joystick->hwdata->userid) {
   242             haptic->index = index;
   243             return SDL_XINPUT_HapticOpenFromUserIndex(haptic, joystick->hwdata->userid);
   244         }
   245         ++index;
   246     }
   247 
   248     SDL_SetError("Couldn't find joystick in haptic device list");
   249     return -1;
   250 }
   251 
   252 void
   253 SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
   254 {
   255     SDL_AtomicSet(&haptic->hwdata->stopThread, 1);
   256     SDL_WaitThread(haptic->hwdata->thread, NULL);
   257     SDL_DestroyMutex(haptic->hwdata->mutex);
   258 }
   259 
   260 void
   261 SDL_XINPUT_HapticQuit(void)
   262 {
   263     if (loaded_xinput) {
   264         WIN_UnloadXInputDLL();
   265         loaded_xinput = SDL_FALSE;
   266     }
   267 }
   268 
   269 int
   270 SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
   271 {
   272     SDL_assert(base->type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
   273     return SDL_XINPUT_HapticUpdateEffect(haptic, effect, base);
   274 }
   275 
   276 int
   277 SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
   278 {
   279     XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
   280     SDL_assert(data->type == SDL_HAPTIC_LEFTRIGHT);
   281     /* SDL_HapticEffect has max magnitude of 32767, XInput expects 65535 max, so multiply */
   282     vib->wLeftMotorSpeed = data->leftright.large_magnitude * 2;
   283     vib->wRightMotorSpeed = data->leftright.small_magnitude * 2;
   284     SDL_LockMutex(haptic->hwdata->mutex);
   285     if (haptic->hwdata->stopTicks) {  /* running right now? Update it. */
   286         XINPUTSETSTATE(haptic->hwdata->userid, vib);
   287     }
   288     SDL_UnlockMutex(haptic->hwdata->mutex);
   289     return 0;
   290 }
   291 
   292 int
   293 SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
   294 {
   295     XINPUT_VIBRATION *vib = &effect->hweffect->vibration;
   296     SDL_assert(effect->effect.type == SDL_HAPTIC_LEFTRIGHT);  /* should catch this at higher level */
   297     SDL_LockMutex(haptic->hwdata->mutex);
   298     if (effect->effect.leftright.length == SDL_HAPTIC_INFINITY || iterations == SDL_HAPTIC_INFINITY) {
   299         haptic->hwdata->stopTicks = SDL_HAPTIC_INFINITY;
   300     } else if ((!effect->effect.leftright.length) || (!iterations)) {
   301         /* do nothing. Effect runs for zero milliseconds. */
   302     } else {
   303         haptic->hwdata->stopTicks = SDL_GetTicks() + (effect->effect.leftright.length * iterations);
   304         if ((haptic->hwdata->stopTicks == SDL_HAPTIC_INFINITY) || (haptic->hwdata->stopTicks == 0)) {
   305             haptic->hwdata->stopTicks = 1;  /* fix edge cases. */
   306         }
   307     }
   308     SDL_UnlockMutex(haptic->hwdata->mutex);
   309     return (XINPUTSETSTATE(haptic->hwdata->userid, vib) == ERROR_SUCCESS) ? 0 : -1;
   310 }
   311 
   312 int
   313 SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   314 {
   315     XINPUT_VIBRATION vibration = { 0, 0 };
   316     SDL_LockMutex(haptic->hwdata->mutex);
   317     haptic->hwdata->stopTicks = 0;
   318     SDL_UnlockMutex(haptic->hwdata->mutex);
   319     return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
   320 }
   321 
   322 void
   323 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   324 {
   325     SDL_XINPUT_HapticStopEffect(haptic, effect);
   326 }
   327 
   328 int
   329 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
   330 {
   331     return SDL_Unsupported();
   332 }
   333 
   334 int
   335 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
   336 {
   337     return SDL_Unsupported();
   338 }
   339 
   340 int
   341 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
   342 {
   343     return SDL_Unsupported();
   344 }
   345 
   346 int
   347 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
   348 {
   349     return SDL_Unsupported();
   350 }
   351 
   352 int
   353 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
   354 {
   355     return SDL_Unsupported();
   356 }
   357 
   358 int
   359 SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
   360 {
   361     XINPUT_VIBRATION vibration = { 0, 0 };
   362     SDL_LockMutex(haptic->hwdata->mutex);
   363     haptic->hwdata->stopTicks = 0;
   364     SDL_UnlockMutex(haptic->hwdata->mutex);
   365     return (XINPUTSETSTATE(haptic->hwdata->userid, &vibration) == ERROR_SUCCESS) ? 0 : -1;
   366 }
   367 
   368 #else /* !SDL_HAPTIC_XINPUT */
   369 
   370 #include "../../core/windows/SDL_windows.h"
   371 
   372 typedef struct SDL_hapticlist_item SDL_hapticlist_item;
   373 
   374 int
   375 SDL_XINPUT_HapticInit(void)
   376 {
   377     return 0;
   378 }
   379 
   380 int
   381 SDL_XINPUT_MaybeAddDevice(const DWORD dwUserid)
   382 {
   383     return SDL_Unsupported();
   384 }
   385 
   386 int
   387 SDL_XINPUT_MaybeRemoveDevice(const DWORD dwUserid)
   388 {
   389     return SDL_Unsupported();
   390 }
   391 
   392 int
   393 SDL_XINPUT_HapticOpen(SDL_Haptic * haptic, SDL_hapticlist_item *item)
   394 {
   395     return SDL_Unsupported();
   396 }
   397 
   398 int
   399 SDL_XINPUT_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
   400 {
   401     return SDL_Unsupported();
   402 }
   403 
   404 int
   405 SDL_XINPUT_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
   406 {
   407     return SDL_Unsupported();
   408 }
   409 
   410 void
   411 SDL_XINPUT_HapticClose(SDL_Haptic * haptic)
   412 {
   413 }
   414 
   415 void
   416 SDL_XINPUT_HapticQuit(void)
   417 {
   418 }
   419 
   420 int
   421 SDL_XINPUT_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * base)
   422 {
   423     return SDL_Unsupported();
   424 }
   425 
   426 int
   427 SDL_XINPUT_HapticUpdateEffect(SDL_Haptic * haptic, struct haptic_effect *effect, SDL_HapticEffect * data)
   428 {
   429     return SDL_Unsupported();
   430 }
   431 
   432 int
   433 SDL_XINPUT_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, Uint32 iterations)
   434 {
   435     return SDL_Unsupported();
   436 }
   437 
   438 int
   439 SDL_XINPUT_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   440 {
   441     return SDL_Unsupported();
   442 }
   443 
   444 void
   445 SDL_XINPUT_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
   446 {
   447 }
   448 
   449 int
   450 SDL_XINPUT_HapticGetEffectStatus(SDL_Haptic * haptic, struct haptic_effect *effect)
   451 {
   452     return SDL_Unsupported();
   453 }
   454 
   455 int
   456 SDL_XINPUT_HapticSetGain(SDL_Haptic * haptic, int gain)
   457 {
   458     return SDL_Unsupported();
   459 }
   460 
   461 int
   462 SDL_XINPUT_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
   463 {
   464     return SDL_Unsupported();
   465 }
   466 
   467 int
   468 SDL_XINPUT_HapticPause(SDL_Haptic * haptic)
   469 {
   470     return SDL_Unsupported();
   471 }
   472 
   473 int
   474 SDL_XINPUT_HapticUnpause(SDL_Haptic * haptic)
   475 {
   476     return SDL_Unsupported();
   477 }
   478 
   479 int
   480 SDL_XINPUT_HapticStopAll(SDL_Haptic * haptic)
   481 {
   482     return SDL_Unsupported();
   483 }
   484 
   485 #endif /* SDL_HAPTIC_XINPUT */
   486 
   487 /* vi: set ts=4 sw=4 expandtab: */