xinput_quigon.patch

diff --git a/dlls/xinput1_3/Makefile.in b/dlls/xinput1_3/Makefile.in
index cf8f730e99..37621faca9 100644
--- a/dlls/xinput1_3/Makefile.in
+++ b/dlls/xinput1_3/Makefile.in
@@ -1,5 +1,6 @@
 MODULE    = xinput1_3.dll
 IMPORTLIB = xinput
+IMPORTS   = uuid dxguid dinput dinput8 ole32
 
 C_SRCS = \
 	xinput1_3_main.c
diff --git a/dlls/xinput1_3/xinput1_3_main.c b/dlls/xinput1_3/xinput1_3_main.c
index 402bd2f468..c1fb6cc98a 100644
--- a/dlls/xinput1_3/xinput1_3_main.c
+++ b/dlls/xinput1_3/xinput1_3_main.c
@@ -1,6 +1,7 @@
 /*
  * The Wine project - Xinput Joystick Library
  * Copyright 2008 Andrew Fenn
+ * Copyright 2016 Bruno Jesus
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,6 +18,7 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#define COBJMACROS
 #include "config.h"
 #include <assert.h>
 #include <stdarg.h>
@@ -27,18 +29,385 @@
 #include "winbase.h"
 #include "winerror.h"
 
+#include "guiddef.h"
 #include "xinput.h"
+#include "dinput.h"
+#include "dinputd.h"
 
 /* Not defined in the headers, used only by XInputGetStateEx */
 #define XINPUT_GAMEPAD_GUIDE 0x0400
 
 WINE_DEFAULT_DEBUG_CHANNEL(xinput);
 
-struct
+struct CapsFlags
 {
-    BOOL connected;
+    BOOL wireless, jedi, pov;
+    int axes, buttons;
+};
+
+static struct ControllerMap
+{
+    LPDIRECTINPUTDEVICE8A device;
+    BOOL connected, acquired;
+    struct CapsFlags caps;
+    XINPUT_STATE_EX state_ex;
+    XINPUT_VIBRATION vibration;
+    BOOL vibration_dirty;
+
+    DIEFFECT effect_data;
+    LPDIRECTINPUTEFFECT effect_instance;
 } controllers[XUSER_MAX_COUNT];
 
+static struct
+{
+    LPDIRECTINPUT8A iface;
+    BOOL enabled;
+    int mapped;
+} dinput;
+
+#define STARTUP_DINPUT if (!dinput.iface) dinput_start();
+
+static const int xbox_buttons[] = {
+    XINPUT_GAMEPAD_A,
+    XINPUT_GAMEPAD_B,
+    XINPUT_GAMEPAD_X,
+    XINPUT_GAMEPAD_Y,
+    XINPUT_GAMEPAD_LEFT_SHOULDER,
+    XINPUT_GAMEPAD_RIGHT_SHOULDER,
+    XINPUT_GAMEPAD_BACK,
+    XINPUT_GAMEPAD_START,
+    XINPUT_GAMEPAD_GUIDE,
+    XINPUT_GAMEPAD_LEFT_THUMB,
+    XINPUT_GAMEPAD_RIGHT_THUMB
+};
+
+/* ========================= Internal functions ============================= */
+
+static BOOL dinput_is_good(const LPDIRECTINPUTDEVICE8A device, struct CapsFlags *caps)
+{
+    HRESULT hr;
+    DIPROPDWORD property;
+    DIDEVCAPS dinput_caps;
+    static const unsigned long wireless_products[] = {
+        MAKELONG(0x045e, 0x0291) /* microsoft receiver */,
+        MAKELONG(0x045e, 0x0719) /* microsoft controller */,
+        MAKELONG(0x0738, 0x4556) /* mad catz */,
+        MAKELONG(0x0e6f, 0x0003) /* logitech */,
+        MAKELONG(0x0e6f, 0x0005) /* eclipse */,
+        MAKELONG(0x0e6f, 0x0006) /* edge */,
+        MAKELONG(0x102c, 0xff0c) /* joytech */
+    };
+    int i;
+
+    dinput_caps.dwSize = sizeof(dinput_caps);
+    hr = IDirectInputDevice_GetCapabilities(device, &dinput_caps);
+    if (FAILED(hr))
+        return FALSE;
+
+    property.diph.dwSize = sizeof(property);
+    property.diph.dwHeaderSize = sizeof(property.diph);
+    property.diph.dwObj = 0;
+    property.diph.dwHow = DIPH_DEVICE;
+
+    hr = IDirectInputDevice_GetProperty(device, DIPROP_VIDPID, &property.diph);
+    if (FAILED(hr))
+        return FALSE;
+
+    if (dinput_caps.dwAxes < 2 || dinput_caps.dwButtons < 8)
+        return FALSE;
+
+    caps->axes = dinput_caps.dwAxes;
+    caps->buttons = dinput_caps.dwButtons;
+    caps->wireless = FALSE;
+    caps->jedi = !!(dinput_caps.dwFlags & DIDC_FORCEFEEDBACK);
+    caps->pov = !!dinput_caps.dwPOVs;
+
+    for (i = 0; i < sizeof(wireless_products) / sizeof(wireless_products[0]); i++)
+        if (property.dwData == wireless_products[i])
+        {
+            caps->wireless = TRUE;
+            break;
+        }
+
+    if (dinput_caps.dwAxes == 6 && dinput_caps.dwButtons == 11  && dinput_caps.dwPOVs == 1)
+        TRACE("This controller has the same number of buttons/axes from xbox 360, should work...\n");
+    else
+        FIXME("This is not a known xbox controller (%d %d %d), using anyway. Expect problems!\n",
+              dinput_caps.dwAxes, dinput_caps.dwButtons, dinput_caps.dwPOVs);
+
+    return TRUE;
+}
+
+static BOOL dinput_set_range(const LPDIRECTINPUTDEVICE8A device)
+{
+    HRESULT hr;
+    DIPROPRANGE property;
+
+    property.diph.dwSize = sizeof(property);
+    property.diph.dwHeaderSize = sizeof(property.diph);
+    property.diph.dwHow = DIPH_DEVICE;
+    property.diph.dwObj = 0;
+    property.lMin = -32767;
+    property.lMax = +32767;
+
+    hr = IDirectInputDevice_SetProperty(device, DIPROP_RANGE, &property.diph);
+    if (FAILED(hr))
+    {
+        WARN("Failed to set axis range (0x%x)\n", hr);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static void dinput_joystate_to_xinput(DIJOYSTATE2 *js, XINPUT_GAMEPAD_EX *gamepad, struct CapsFlags *caps)
+{
+    int i, buttons;
+
+    gamepad->dwPaddingReserved = 0;
+    gamepad->wButtons = 0x0000;
+    /* First the D-Pad which is recognized as a POV in dinput */
+    if (caps->pov)
+    {
+        switch (js->rgdwPOV[0])
+        {
+            case 0    : gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_UP; break;
+            case 4500 : gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_UP; /* fall through */
+            case 9000 : gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT; break;
+            case 13500: gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT; /* fall through */
+            case 18000: gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_DOWN; break;
+            case 22500: gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_DOWN; /* fall through */
+            case 27000: gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_LEFT; break;
+            case 31500: gamepad->wButtons |= XINPUT_GAMEPAD_DPAD_LEFT | XINPUT_GAMEPAD_DPAD_UP;
+        }
+    }
+
+    /* Buttons */
+    buttons = min(caps->buttons, sizeof(xbox_buttons) / sizeof(*xbox_buttons));
+    for (i = 0; i < buttons; i++)
+        if (js->rgbButtons[i] & 0x80)
+            gamepad->wButtons |= xbox_buttons[i];
+
+    /* Axes */
+    gamepad->sThumbLX = js->lX;
+    gamepad->sThumbLY = -js->lY;
+    if (caps->axes >= 4)
+    {
+        gamepad->sThumbRX = js->lRx;
+        gamepad->sThumbRY = -js->lRy;
+    }
+    else
+        gamepad->sThumbRX = gamepad->sThumbRY = 0;
+
+    /* Both triggers */
+    if (caps->axes >= 6)
+    {
+        gamepad->bLeftTrigger = (js->lZ + 32767) * 255 / 65534;
+        gamepad->bRightTrigger = (js->lRz + 32767) * 255 / 65534;
+    }
+    else
+        gamepad->bLeftTrigger = gamepad->bRightTrigger = 0;
+}
+
+static BOOL dinput_acquire(int index)
+{
+    HRESULT hr;
+
+    if (!controllers[index].acquired)
+    {
+        IDirectInputDevice8_SetDataFormat(controllers[index].device, &c_dfDIJoystick2);
+        hr = IDirectInputDevice8_Acquire(controllers[index].device);
+        if (FAILED(hr))
+            WARN("Failed to acquire game controller (0x%x)\n", hr);
+        else
+            controllers[index].acquired = TRUE;
+    }
+
+    return controllers[index].acquired;
+}
+
+static void dinput_fill_effect(DIEFFECT *effect)
+{
+    static DWORD axes[2] = {DIJOFS_X, DIJOFS_Y};
+    static LONG direction[2] = {0, 0};
+
+    effect->dwSize = sizeof(*effect);
+    effect->dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
+    effect->dwDuration = INFINITE;
+    effect->dwGain = 0;
+    effect->dwTriggerButton = DIEB_NOTRIGGER;
+    effect->cAxes = sizeof(axes) / sizeof(axes[0]);
+    effect->rgdwAxes = axes;
+    effect->rglDirection = direction;
+}
+
+static void dinput_send_effect(int index, int strength)
+{
+    HRESULT hr;
+    union
+    {
+        DICONSTANTFORCE constant;
+        DIPERIODIC periodic;
+    } u;
+    DIEFFECT *effect = &controllers[index].effect_data;
+    LPDIRECTINPUTEFFECT *instance = &controllers[index].effect_instance;
+
+    if (!dinput_acquire(index))
+      return;
+
+    if (!*instance)
+        dinput_fill_effect(effect);
+
+    u.periodic.dwMagnitude = strength; /* constant force uses this same value */
+    u.periodic.dwPeriod = DI_SECONDS; /* 1 second */
+    u.periodic.lOffset = 0;
+    u.periodic.dwPhase = 0;
+
+    effect->lpvTypeSpecificParams = &u.periodic;
+
+    if (!*instance)
+    {
+        static GUID types[2];
+        int i;
+
+        types[0] = GUID_Square;
+        types[1] = GUID_ConstantForce;
+        for (i = 0; i < 2; i++)
+        {
+            effect->cbTypeSpecificParams = !i ? sizeof(u.periodic) : sizeof(u.constant);
+
+            hr = IDirectInputDevice8_CreateEffect(controllers[index].device, &types[i],
+                                                  effect, instance, NULL);
+            if (FAILED(hr))
+                continue;
+
+            if (!*instance)
+                continue;
+
+            hr = IDirectInputEffect_SetParameters(*instance, effect,
+                    DIEP_AXES | DIEP_DIRECTION | DIEP_NODOWNLOAD | DIEP_TYPESPECIFICPARAMS);
+            if (FAILED(hr))
+            {
+                IUnknown_Release(*instance);
+                *instance = NULL;
+                continue;
+            }
+            TRACE("Using %s effect for vibration\n", i ? "square" : "constant");
+            break;
+        }
+        if (i == 2)
+        {
+            WARN("Failed to create effect (hr 0x%x, instance %p)\n", hr, *instance);
+            return;
+        }
+    }
+    else
+    {
+        GUID guid;
+
+        IDirectInputEffect_GetEffectGuid(*instance, &guid);
+        effect->cbTypeSpecificParams = IsEqualGUID(&GUID_Square, &guid) ? sizeof(u.periodic) : sizeof(u.constant);
+    }
+
+    hr = IDirectInputEffect_SetParameters(*instance, effect, DIEP_TYPESPECIFICPARAMS | DIEP_START);
+    if (FAILED(hr))
+        WARN("Failed to play effect (0x%x)\n", hr);
+}
+
+static BOOL CALLBACK dinput_enum_callback(const DIDEVICEINSTANCEA *instance, void *context)
+{
+    LPDIRECTINPUTDEVICE8A device;
+    HRESULT hr;
+
+    if (dinput.mapped == sizeof(controllers) / sizeof(*controllers))
+        return DIENUM_STOP;
+
+    hr = IDirectInput_CreateDevice(dinput.iface, &instance->guidInstance, &device, NULL);
+    if (FAILED(hr))
+        return DIENUM_CONTINUE;
+
+    if (!dinput_is_good(device, &controllers[dinput.mapped].caps))
+    {
+        IDirectInput_Release(device);
+        return DIENUM_CONTINUE;
+    }
+
+    if (!dinput_set_range(device))
+    {
+        IDirectInput_Release(device);
+        return DIENUM_CONTINUE;
+    }
+
+    controllers[dinput.mapped].connected = TRUE;
+    controllers[dinput.mapped].device = device;
+    dinput.mapped++;
+
+    return DIENUM_CONTINUE;
+}
+
+static void dinput_start(void)
+{
+    HRESULT hr;
+
+    hr = DirectInput8Create(GetModuleHandleA(NULL), 0x0800, &IID_IDirectInput8A,
+                            (void **)&dinput.iface, NULL);
+    if (FAILED(hr))
+    {
+        ERR("Failed to create dinput8 interface, no xinput controller support (0x%x)\n", hr);
+        return;
+    }
+
+    hr = IDirectInput8_EnumDevices(dinput.iface, DI8DEVCLASS_GAMECTRL,
+                                   dinput_enum_callback, NULL, DIEDFL_ATTACHEDONLY);
+    if (FAILED(hr))
+    {
+        ERR("Failed to enumerate dinput8 devices, no xinput controller support (0x%x)\n", hr);
+        return;
+    }
+
+    dinput.enabled = TRUE;
+}
+
+static void dinput_update(int index)
+{
+    HRESULT hr;
+    DIJOYSTATE2 data;
+    XINPUT_GAMEPAD_EX gamepad;
+
+    if (dinput.enabled)
+    {
+        if (!dinput_acquire(index))
+            return;
+
+        hr = IDirectInputDevice_GetDeviceState(controllers[index].device, sizeof(data), &data);
+        if (FAILED(hr))
+        {
+            if (hr == DIERR_INPUTLOST)
+                controllers[index].acquired = FALSE;
+            WARN("Failed to get game controller state (0x%x)\n", hr);
+            return;
+        }
+        dinput_joystate_to_xinput(&data, &gamepad, &controllers[index].caps);
+    }
+    else
+        memset(&gamepad, 0, sizeof(gamepad));
+
+    if (memcmp(&controllers[index].state_ex.Gamepad, &gamepad, sizeof(gamepad)))
+    {
+        controllers[index].state_ex.Gamepad = gamepad;
+        controllers[index].state_ex.dwPacketNumber++;
+        TRACE("Buttons 0x%x, LT %d, RT %d, LX %d, LY %d, RX %d, RY %d\n",
+              gamepad.wButtons,
+              gamepad.bLeftTrigger,
+              gamepad.bRightTrigger,
+              gamepad.sThumbLX,
+              gamepad.sThumbLY,
+              gamepad.sThumbRX,
+              gamepad.sThumbRY);
+    }
+}
+
+/* ============================ Dll Functions =============================== */
+
 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
 {
     switch(reason)
@@ -52,23 +421,54 @@ BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
 
 void WINAPI DECLSPEC_HOTPATCH XInputEnable(BOOL enable)
 {
-    /* Setting to false will stop messages from XInputSetState being sent
-    to the controllers. Setting to true will send the last vibration
-    value (sent to XInputSetState) to the controller and allow messages to
-    be sent */
-    FIXME("(enable %d) Stub!\n", enable);
+    TRACE("(%d)\n", enable);
+
+    STARTUP_DINPUT
+
+    if((dinput.enabled = enable))
+    {
+        int i;
+        /* Apply the last vibration status that was sent to the controller
+         * while xinput was disabled. */
+        for (i = 0; i < sizeof(controllers) / sizeof(*controllers); i++)
+        {
+            if (controllers[i].connected && controllers[i].vibration_dirty)
+                XInputSetState(i, &controllers[i].vibration);
+        }
+    }
 }
 
 DWORD WINAPI XInputSetState(DWORD index, XINPUT_VIBRATION* vibration)
 {
-    FIXME("(index %u, vibration %p) Stub!\n", index, vibration);
+    TRACE("(index %u, vibration %p)\n", index, vibration);
+
+    STARTUP_DINPUT
 
     if (index >= XUSER_MAX_COUNT)
         return ERROR_BAD_ARGUMENTS;
     if (!controllers[index].connected)
         return ERROR_DEVICE_NOT_CONNECTED;
 
-    return ERROR_NOT_SUPPORTED;
+    /* Check if we really have to do all the process */
+    if (!controllers[index].vibration_dirty &&
+        controllers[index].vibration.wLeftMotorSpeed == vibration->wLeftMotorSpeed &&
+        controllers[index].vibration.wRightMotorSpeed == vibration->wRightMotorSpeed)
+        return ERROR_SUCCESS;
+
+    controllers[index].vibration = *vibration;
+    controllers[index].vibration_dirty = !dinput.enabled;
+
+    if (dinput.enabled && controllers[index].caps.jedi)
+    {
+        int strength;
+        /* FIXME: we can't set the speed of each motor so do an average */
+        strength = DI_FFNOMINALMAX * (vibration->wLeftMotorSpeed + vibration->wRightMotorSpeed) / 2 / 0xFFFF;
+
+        TRACE("Vibration left/right speed %d/%d translated to %d\n\n",
+              vibration->wLeftMotorSpeed, vibration->wRightMotorSpeed, strength);
+        dinput_send_effect(index, strength);
+    }
+    return ERROR_SUCCESS;
 }
 
 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetState(DWORD index, XINPUT_STATE* state)
@@ -79,35 +479,39 @@ DWORD WINAPI DECLSPEC_HOTPATCH XInputGetState(DWORD index, XINPUT_STATE* state)
         XINPUT_STATE_EX state_ex;
     } xinput;
     DWORD ret;
-    static int warn_once;
 
-    if (!warn_once++)
-        FIXME("(index %u, state %p) Stub!\n", index, state);
+    TRACE("(%u %p)\n", index, state);
 
     ret = XInputGetStateEx(index, &xinput.state_ex);
     if (ret != ERROR_SUCCESS)
         return ret;
 
     /* The main difference between this and the Ex version is the media guide button */
-    xinput.state.Gamepad.wButtons &= ~XINPUT_GAMEPAD_GUIDE;
     *state = xinput.state;
+    state->Gamepad.wButtons &= ~XINPUT_GAMEPAD_GUIDE;
 
     return ERROR_SUCCESS;
 }
 
 DWORD WINAPI DECLSPEC_HOTPATCH XInputGetStateEx(DWORD index, XINPUT_STATE_EX* state_ex)
 {
-    static int warn_once;
+    TRACE("(%u %p)\n", index, state_ex);
 
-    if (!warn_once++)
-        FIXME("(index %u, state %p) Stub!\n", index, state_ex);
+    STARTUP_DINPUT
 
     if (index >= XUSER_MAX_COUNT)
         return ERROR_BAD_ARGUMENTS;
     if (!controllers[index].connected)
         return ERROR_DEVICE_NOT_CONNECTED;
 
-    return ERROR_NOT_SUPPORTED;
+    dinput_update(index);
+
+    /* Broforce does not pass a correct XINPUT_STATE_EX and crashes, so only
+     * copy the old struct size as the new parameter is reserved anyway */
+    state_ex->dwPacketNumber = controllers[index].state_ex.dwPacketNumber;
+    *(XINPUT_GAMEPAD *)&state_ex->Gamepad = *(XINPUT_GAMEPAD *)&controllers[index].state_ex.Gamepad;
+
+    return ERROR_SUCCESS;
 }
 
 DWORD WINAPI XInputGetKeystroke(DWORD index, DWORD reserved, PXINPUT_KEYSTROKE keystroke)
@@ -117,27 +521,77 @@ DWORD WINAPI XInputGetKeystroke(DWORD index, DWORD reserved, PXINPUT_KEYSTROKE k
     if (!warn_once++)
         FIXME("(index %u, reserved %u, keystroke %p) Stub!\n", index, reserved, keystroke);
 
-    if (index >= XUSER_MAX_COUNT)
-        return ERROR_BAD_ARGUMENTS;
-    if (!controllers[index].connected)
-        return ERROR_DEVICE_NOT_CONNECTED;
+    if (index != XUSER_INDEX_ANY)
+    {
+        if (index >= XUSER_MAX_COUNT)
+            return ERROR_BAD_ARGUMENTS;
+        if (!controllers[index].connected)
+            return ERROR_DEVICE_NOT_CONNECTED;
+    }
 
-    return ERROR_NOT_SUPPORTED;
+    /* Pretend no keys are pressed */
+    return ERROR_EMPTY;
 }
 
+/* Not defined anywhere ??? */
+#define XINPUT_CAPS_FFB_SUPPORTED 0x0001
+#define XINPUT_CAPS_WIRELESS      0x0002
+#define XINPUT_CAPS_NO_NAVIGATION 0x0010
+
 DWORD WINAPI XInputGetCapabilities(DWORD index, DWORD flags, XINPUT_CAPABILITIES* capabilities)
 {
-    static int warn_once;
+    WORD bits = 0, i;
+    TRACE("(%u %d %p)\n", index, flags, capabilities);
 
-    if (!warn_once++)
-        FIXME("(index %u, flags 0x%x, capabilities %p) Stub!\n", index, flags, capabilities);
+    STARTUP_DINPUT
 
     if (index >= XUSER_MAX_COUNT)
         return ERROR_BAD_ARGUMENTS;
     if (!controllers[index].connected)
         return ERROR_DEVICE_NOT_CONNECTED;
 
-    return ERROR_NOT_SUPPORTED;
+    capabilities->Type = XINPUT_DEVTYPE_GAMEPAD;
+    capabilities->SubType = XINPUT_DEVSUBTYPE_GAMEPAD;
+
+    capabilities->Flags = 0;
+    if (controllers[index].caps.jedi)
+    {
+        capabilities->Flags |= XINPUT_CAPS_FFB_SUPPORTED;
+        capabilities->Vibration.wLeftMotorSpeed = 1;
+        capabilities->Vibration.wRightMotorSpeed = 1;
+    }
+    else
+    {
+        capabilities->Vibration.wLeftMotorSpeed = 0;
+        capabilities->Vibration.wRightMotorSpeed = 0;
+    }
+    if (controllers[index].caps.wireless)
+        capabilities->Flags |= XINPUT_CAPS_WIRELESS;
+    if (!controllers[index].caps.pov)
+        capabilities->Flags |= XINPUT_CAPS_NO_NAVIGATION;
+    else
+        bits = 0xF;
+
+    for (i = 0; i < controllers[index].caps.buttons &&
+                i < sizeof(xbox_buttons) / sizeof(*xbox_buttons); i++)
+        bits |= xbox_buttons[i];
+
+    bits &= ~XINPUT_GAMEPAD_GUIDE;
+    capabilities->Gamepad.wButtons = bits;
+
+    capabilities->Gamepad.sThumbLX = capabilities->Gamepad.sThumbLY = 1;
+
+    if (controllers[index].caps.axes >= 4)
+        capabilities->Gamepad.sThumbRX = capabilities->Gamepad.sThumbRY = 1;
+    else
+        capabilities->Gamepad.sThumbRX = capabilities->Gamepad.sThumbRY = 0;
+
+    if (controllers[index].caps.axes >= 6)
+        capabilities->Gamepad.bLeftTrigger = capabilities->Gamepad.bRightTrigger = 1;
+    else
+        capabilities->Gamepad.bLeftTrigger = capabilities->Gamepad.bRightTrigger = 0;
+
+    return ERROR_SUCCESS;
 }
 
 DWORD WINAPI XInputGetDSoundAudioDeviceGuids(DWORD index, GUID* render_guid, GUID* capture_guid)
@@ -149,17 +603,43 @@ DWORD WINAPI XInputGetDSoundAudioDeviceGuids(DWORD index, GUID* render_guid, GUI
     if (!controllers[index].connected)
         return ERROR_DEVICE_NOT_CONNECTED;
 
-    return ERROR_NOT_SUPPORTED;
+    /* Tests show that it is more appropriate to return GUID_NULL and success,
+     * this means that a controller is connected but the headset is not. */
+    if (render_guid)
+      *render_guid = GUID_NULL;
+    if (capture_guid)
+      *capture_guid = GUID_NULL;
+
+    return ERROR_SUCCESS;
 }
 
 DWORD WINAPI XInputGetBatteryInformation(DWORD index, BYTE type, XINPUT_BATTERY_INFORMATION* battery)
 {
-    FIXME("(index %u, type %u, battery %p) Stub!\n", index, type, battery);
+    TRACE("(%u %u %p) Stub!\n", index, type, battery);
+
+    STARTUP_DINPUT
 
     if (index >= XUSER_MAX_COUNT)
         return ERROR_BAD_ARGUMENTS;
     if (!controllers[index].connected)
         return ERROR_DEVICE_NOT_CONNECTED;
+    if (type != BATTERY_DEVTYPE_GAMEPAD && type != BATTERY_DEVTYPE_HEADSET)
+        return ERROR_BAD_ARGUMENTS;
+
+    if (!controllers[index].caps.wireless)
+    {
+        battery->BatteryType = BATTERY_TYPE_WIRED;
+        battery->BatteryLevel = BATTERY_LEVEL_FULL;
+    }
+    else
+    {
+        static int once;
+        if (!once++)
+            FIXME("Reporting fake battery values\n");
+
+        battery->BatteryType = BATTERY_TYPE_NIMH;
+        battery->BatteryLevel = BATTERY_LEVEL_MEDIUM;
+    }
 
-    return ERROR_NOT_SUPPORTED;
+    return ERROR_SUCCESS;
 }