modules/rostests/winetests/xinput1_3/xinput.c

   1 /*
   2  * The Wine project - Xinput Joystick Library
   3  * Copyright 2008 Andrew Fenn
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <windows.h>
  21 #include <stdio.h>
  22
  23 #include "xinput.h"
  24 #include "wine/test.h"
  25
  26 static DWORD (WINAPI *pXInputGetState)(DWORD, XINPUT_STATE*);
  27 static DWORD (WINAPI *pXInputGetStateEx)(DWORD, XINPUT_STATE*);
  28 static DWORD (WINAPI *pXInputGetCapabilities)(DWORD,DWORD,XINPUT_CAPABILITIES*);
  29 static DWORD (WINAPI *pXInputSetState)(DWORD, XINPUT_VIBRATION*);
  30 static void  (WINAPI *pXInputEnable)(BOOL);
  31 static DWORD (WINAPI *pXInputGetKeystroke)(DWORD, DWORD, PXINPUT_KEYSTROKE);
  32 static DWORD (WINAPI *pXInputGetDSoundAudioDeviceGuids)(DWORD, GUID*, GUID*);
  33 static DWORD (WINAPI *pXInputGetBatteryInformation)(DWORD, BYTE, XINPUT_BATTERY_INFORMATION*);
  34
  35 static void dump_gamepad(XINPUT_GAMEPAD *data)
  36 {
  37     trace("-- Gamepad Variables --\n");
  38     trace("Gamepad.wButtons: %#x\n", data->wButtons);
  39     trace("Gamepad.bLeftTrigger: %d\n", data->bLeftTrigger);
  40     trace("Gamepad.bRightTrigger: %d\n", data->bRightTrigger);
  41     trace("Gamepad.sThumbLX: %d\n", data->sThumbLX);
  42     trace("Gamepad.sThumbLY: %d\n", data->sThumbLY);
  43     trace("Gamepad.sThumbRX: %d\n", data->sThumbRX);
  44     trace("Gamepad.sThumbRY: %d\n\n", data->sThumbRY);
  45 }
  46
  47 static void test_set_state(void)
  48 {
  49     XINPUT_VIBRATION vibrator;
  50     DWORD controllerNum;
  51     DWORD result;
  52
  53     for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
  54     {
  55         ZeroMemory(&vibrator, sizeof(XINPUT_VIBRATION));
  56
  57         vibrator.wLeftMotorSpeed = 32767;
  58         vibrator.wRightMotorSpeed = 32767;
  59         result = pXInputSetState(controllerNum, &vibrator);
  60         if (result == ERROR_DEVICE_NOT_CONNECTED) continue;
  61
  62         Sleep(250);
  63         vibrator.wLeftMotorSpeed = 0;
  64         vibrator.wRightMotorSpeed = 0;
  65         result = pXInputSetState(controllerNum, &vibrator);
  66         ok(result == ERROR_SUCCESS, "XInputSetState failed with (%d)\n", result);
  67
  68         /* Disabling XInput here, queueing a vibration and then re-enabling XInput
  69          * is used to prove that vibrations are auto enabled when resuming XInput.
  70          * If XInputEnable(1) is removed below the vibration will never play. */
  71         if (pXInputEnable) pXInputEnable(0);
  72
  73         Sleep(250);
  74         vibrator.wLeftMotorSpeed = 65535;
  75         vibrator.wRightMotorSpeed = 65535;
  76         result = pXInputSetState(controllerNum, &vibrator);
  77         ok(result == ERROR_SUCCESS, "XInputSetState failed with (%d)\n", result);
  78
  79         if (pXInputEnable) pXInputEnable(1);
  80         Sleep(250);
  81
  82         vibrator.wLeftMotorSpeed = 0;
  83         vibrator.wRightMotorSpeed = 0;
  84         result = pXInputSetState(controllerNum, &vibrator);
  85         ok(result == ERROR_SUCCESS, "XInputSetState failed with (%d)\n", result);
  86     }
  87
  88     result = pXInputSetState(XUSER_MAX_COUNT+1, &vibrator);
  89     ok(result == ERROR_BAD_ARGUMENTS, "XInputSetState returned (%d)\n", result);
  90 }
  91
  92 static void test_get_state(void)
  93 {
  94     XINPUT_STATE state;
  95     DWORD controllerNum, i, result, good = XUSER_MAX_COUNT;
  96
  97     for (i = 0; i < (pXInputGetStateEx ? 2 : 1); i++)
  98     {
  99         for (controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
 100         {
 101             ZeroMemory(&state, sizeof(state));
 102
 103             if (i == 0)
 104                 result = pXInputGetState(controllerNum, &state);
 105             else
 106                 result = pXInputGetStateEx(controllerNum, &state);
 107             ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED,
 108                "%s failed with (%d)\n", i == 0 ? "XInputGetState" : "XInputGetStateEx", result);
 109
 110             if (ERROR_DEVICE_NOT_CONNECTED == result)
 111             {
 112                 skip("Controller %d is not connected\n", controllerNum);
 113                 continue;
 114             }
 115
 116             trace("-- Results for controller %d --\n", controllerNum);
 117             if (i == 0)
 118             {
 119                 good = controllerNum;
 120                 trace("XInputGetState: %d\n", result);
 121             }
 122             else
 123                 trace("XInputGetStateEx: %d\n", result);
 124             trace("State->dwPacketNumber: %d\n", state.dwPacketNumber);
 125             dump_gamepad(&state.Gamepad);
 126         }
 127     }
 128
 129     result = pXInputGetState(XUSER_MAX_COUNT, &state);
 130     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned (%d)\n", result);
 131
 132     result = pXInputGetState(XUSER_MAX_COUNT+1, &state);
 133     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned (%d)\n", result);
 134     if (pXInputGetStateEx)
 135     {
 136         result = pXInputGetStateEx(XUSER_MAX_COUNT, &state);
 137         ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned (%d)\n", result);
 138
 139         result = pXInputGetStateEx(XUSER_MAX_COUNT+1, &state);
 140         ok(result == ERROR_BAD_ARGUMENTS, "XInputGetState returned (%d)\n", result);
 141     }
 142
 143     if (winetest_interactive && good < XUSER_MAX_COUNT)
 144     {
 145         DWORD now = GetTickCount(), packet = 0;
 146         XINPUT_GAMEPAD *game = &state.Gamepad;
 147
 148         trace("You have 20 seconds to test the joystick freely\n");
 149         do
 150         {
 151             Sleep(100);
 152             pXInputGetState(good, &state);
 153             if (state.dwPacketNumber == packet)
 154                 continue;
 155
 156             packet = state.dwPacketNumber;
 157             trace("Buttons 0x%04X Triggers %3d/%3d LT %6d/%6d RT %6d/%6d\n",
 158                   game->wButtons, game->bLeftTrigger, game->bRightTrigger,
 159                   game->sThumbLX, game->sThumbLY, game->sThumbRX, game->sThumbRY);
 160         }
 161         while(GetTickCount() - now < 20000);
 162         trace("Test over...\n");
 163     }
 164 }
 165
 166 static void test_get_keystroke(void)
 167 {
 168     XINPUT_KEYSTROKE keystroke;
 169     DWORD controllerNum;
 170     DWORD result;
 171
 172     for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
 173     {
 174         ZeroMemory(&keystroke, sizeof(XINPUT_KEYSTROKE));
 175
 176         result = pXInputGetKeystroke(controllerNum, XINPUT_FLAG_GAMEPAD, &keystroke);
 177         ok(result == ERROR_EMPTY || result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED,
 178            "XInputGetKeystroke failed with (%d)\n", result);
 179
 180         if (ERROR_DEVICE_NOT_CONNECTED == result)
 181         {
 182             skip("Controller %d is not connected\n", controllerNum);
 183         }
 184     }
 185
 186     ZeroMemory(&keystroke, sizeof(XINPUT_KEYSTROKE));
 187     result = pXInputGetKeystroke(XUSER_MAX_COUNT+1, XINPUT_FLAG_GAMEPAD, &keystroke);
 188     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetKeystroke returned (%d)\n", result);
 189 }
 190
 191 static void test_get_capabilities(void)
 192 {
 193     XINPUT_CAPABILITIES capabilities;
 194     DWORD controllerNum;
 195     DWORD result;
 196
 197     for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
 198     {
 199         ZeroMemory(&capabilities, sizeof(XINPUT_CAPABILITIES));
 200
 201         result = pXInputGetCapabilities(controllerNum, XINPUT_FLAG_GAMEPAD, &capabilities);
 202         ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetCapabilities failed with (%d)\n", result);
 203
 204         if (ERROR_DEVICE_NOT_CONNECTED == result)
 205         {
 206             skip("Controller %d is not connected\n", controllerNum);
 207             continue;
 208         }
 209
 210         /* Important to show that the results changed between 1.3 and 1.4 XInput version */
 211         dump_gamepad(&capabilities.Gamepad);
 212     }
 213
 214     ZeroMemory(&capabilities, sizeof(XINPUT_CAPABILITIES));
 215     result = pXInputGetCapabilities(XUSER_MAX_COUNT+1, XINPUT_FLAG_GAMEPAD, &capabilities);
 216     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetCapabilities returned (%d)\n", result);
 217 }
 218
 219 static void test_get_dsoundaudiodevice(void)
 220 {
 221     DWORD controllerNum;
 222     DWORD result;
 223     GUID soundRender, soundCapture;
 224     GUID testGuid = {0xFFFFFFFF, 0xFFFF, 0xFFFF, {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};
 225     GUID emptyGuid = {0x0, 0x0, 0x0, {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}};
 226
 227     for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
 228     {
 229         soundRender = soundCapture = testGuid;
 230         result = pXInputGetDSoundAudioDeviceGuids(controllerNum, &soundRender, &soundCapture);
 231         ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetDSoundAudioDeviceGuids failed with (%d)\n", result);
 232
 233         if (ERROR_DEVICE_NOT_CONNECTED == result)
 234         {
 235             skip("Controller %d is not connected\n", controllerNum);
 236             continue;
 237         }
 238
 239         if (!IsEqualGUID(&soundRender, &emptyGuid))
 240             ok(!IsEqualGUID(&soundRender, &testGuid), "Broken GUID returned for sound render device\n");
 241         else
 242             trace("Headset phone not attached\n");
 243
 244         if (!IsEqualGUID(&soundCapture, &emptyGuid))
 245             ok(!IsEqualGUID(&soundCapture, &testGuid), "Broken GUID returned for sound capture device\n");
 246         else
 247             trace("Headset microphone not attached\n");
 248     }
 249
 250     result = pXInputGetDSoundAudioDeviceGuids(XUSER_MAX_COUNT+1, &soundRender, &soundCapture);
 251     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetDSoundAudioDeviceGuids returned (%d)\n", result);
 252 }
 253
 254 static void test_get_batteryinformation(void)
 255 {
 256     DWORD controllerNum;
 257     DWORD result;
 258     XINPUT_BATTERY_INFORMATION batteryInfo;
 259
 260     for(controllerNum = 0; controllerNum < XUSER_MAX_COUNT; controllerNum++)
 261     {
 262         ZeroMemory(&batteryInfo, sizeof(XINPUT_BATTERY_INFORMATION));
 263
 264         result = pXInputGetBatteryInformation(controllerNum, BATTERY_DEVTYPE_GAMEPAD, &batteryInfo);
 265         ok(result == ERROR_SUCCESS || result == ERROR_DEVICE_NOT_CONNECTED, "XInputGetBatteryInformation failed with (%d)\n", result);
 266
 267         if (ERROR_DEVICE_NOT_CONNECTED == result)
 268         {
 269             ok(batteryInfo.BatteryLevel == BATTERY_TYPE_DISCONNECTED, "Failed to report device as being disconnected.\n");
 270             skip("Controller %d is not connected\n", controllerNum);
 271         }
 272     }
 273
 274     result = pXInputGetBatteryInformation(XUSER_MAX_COUNT+1, BATTERY_DEVTYPE_GAMEPAD, &batteryInfo);
 275     ok(result == ERROR_BAD_ARGUMENTS, "XInputGetBatteryInformation returned (%d)\n", result);
 276 }
 277
 278 START_TEST(xinput)
 279 {
 280     struct
 281     {
 282         const char *name;
 283         int version;
 284     } libs[] = {
 285         { "xinput1_1.dll",   1 },
 286         { "xinput1_2.dll",   2 },
 287         { "xinput1_3.dll",   3 },
 288         { "xinput1_4.dll",   4 },
 289         { "xinput9_1_0.dll", 0 } /* legacy for XP/Vista */
 290     };
 291     HMODULE hXinput;
 292     void *pXInputGetStateEx_Ordinal;
 293     int i;
 294
 295     for (i = 0; i < sizeof(libs) / sizeof(libs[0]); i++)
 296     {
 297         hXinput = LoadLibraryA( libs[i].name );
 298
 299         if (!hXinput)
 300         {
 301             win_skip("Could not load %s\n", libs[i].name);
 302             continue;
 303         }
 304         trace("Testing %s\n", libs[i].name);
 305
 306         pXInputEnable = (void*)GetProcAddress(hXinput, "XInputEnable");
 307         pXInputSetState = (void*)GetProcAddress(hXinput, "XInputSetState");
 308         pXInputGetState = (void*)GetProcAddress(hXinput, "XInputGetState");
 309         pXInputGetStateEx = (void*)GetProcAddress(hXinput, "XInputGetStateEx"); /* Win >= 8 */
 310         pXInputGetStateEx_Ordinal = (void*)GetProcAddress(hXinput, (LPCSTR) 100);
 311         pXInputGetKeystroke = (void*)GetProcAddress(hXinput, "XInputGetKeystroke");
 312         pXInputGetCapabilities = (void*)GetProcAddress(hXinput, "XInputGetCapabilities");
 313         pXInputGetDSoundAudioDeviceGuids = (void*)GetProcAddress(hXinput, "XInputGetDSoundAudioDeviceGuids");
 314         pXInputGetBatteryInformation = (void*)GetProcAddress(hXinput, "XInputGetBatteryInformation");
 315
 316         /* XInputGetStateEx may not be present by name, use ordinal in this case */
 317         if (!pXInputGetStateEx)
 318             pXInputGetStateEx = pXInputGetStateEx_Ordinal;
 319
 320         test_set_state();
 321         test_get_state();
 322         test_get_capabilities();
 323
 324         if (libs[i].version != 4)
 325             test_get_dsoundaudiodevice();
 326         else
 327             ok(!pXInputGetDSoundAudioDeviceGuids, "XInputGetDSoundAudioDeviceGuids exists in %s\n", libs[i].name);
 328
 329         if (libs[i].version > 2)
 330         {
 331             test_get_keystroke();
 332             test_get_batteryinformation();
 333             ok(pXInputGetStateEx != NULL, "XInputGetStateEx not found in %s\n", libs[i].name);
 334         }
 335         else
 336         {
 337             ok(!pXInputGetKeystroke, "XInputGetKeystroke exists in %s\n", libs[i].name);
 338             ok(!pXInputGetStateEx, "XInputGetStateEx exists in %s\n", libs[i].name);
 339             ok(!pXInputGetBatteryInformation, "XInputGetBatteryInformation exists in %s\n", libs[i].name);
 340             if (libs[i].version == 0)
 341                 ok(!pXInputEnable, "XInputEnable exists in %s\n", libs[i].name);
 342         }
 343
 344         FreeLibrary(hXinput);
 345     }
 346 }