content/browser/gamepad/gamepad_platform_data_fetcher_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/gamepad/gamepad_platform_data_fetcher_win.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/win/windows_version.h"
  10 #include "content/common/gamepad_hardware_buffer.h"
  11 #include "content/common/gamepad_messages.h"
  12
  13 namespace content {
  14
  15 using namespace blink;
  16
  17 namespace {
  18
  19 // See http://goo.gl/5VSJR. These are not available in all versions of the
  20 // header, but they can be returned from the driver, so we define our own
  21 // versions here.
  22 static const BYTE kDeviceSubTypeGamepad = 1;
  23 static const BYTE kDeviceSubTypeWheel = 2;
  24 static const BYTE kDeviceSubTypeArcadeStick = 3;
  25 static const BYTE kDeviceSubTypeFlightStick = 4;
  26 static const BYTE kDeviceSubTypeDancePad = 5;
  27 static const BYTE kDeviceSubTypeGuitar = 6;
  28 static const BYTE kDeviceSubTypeGuitarAlternate = 7;
  29 static const BYTE kDeviceSubTypeDrumKit = 8;
  30 static const BYTE kDeviceSubTypeGuitarBass = 11;
  31 static const BYTE kDeviceSubTypeArcadePad = 19;
  32
  33 float NormalizeXInputAxis(SHORT value) {
  34   return ((value + 32768.f) / 32767.5f) - 1.f;
  35 }
  36
  37 const WebUChar* const GamepadSubTypeName(BYTE sub_type) {
  38   switch (sub_type) {
  39     case kDeviceSubTypeGamepad: return L"GAMEPAD";
  40     case kDeviceSubTypeWheel: return L"WHEEL";
  41     case kDeviceSubTypeArcadeStick: return L"ARCADE_STICK";
  42     case kDeviceSubTypeFlightStick: return L"FLIGHT_STICK";
  43     case kDeviceSubTypeDancePad: return L"DANCE_PAD";
  44     case kDeviceSubTypeGuitar: return L"GUITAR";
  45     case kDeviceSubTypeGuitarAlternate: return L"GUITAR_ALTERNATE";
  46     case kDeviceSubTypeDrumKit: return L"DRUM_KIT";
  47     case kDeviceSubTypeGuitarBass: return L"GUITAR_BASS";
  48     case kDeviceSubTypeArcadePad: return L"ARCADE_PAD";
  49     default: return L"<UNKNOWN>";
  50   }
  51 }
  52
  53 }  // namespace
  54
  55 GamepadPlatformDataFetcherWin::GamepadPlatformDataFetcherWin()
  56     : xinput_dll_(base::FilePath(FILE_PATH_LITERAL("xinput1_3.dll"))),
  57       xinput_available_(GetXInputDllFunctions()) {
  58   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i)
  59     pad_state_[i].status = DISCONNECTED;
  60
  61   raw_input_fetcher_.reset(new RawInputDataFetcher());
  62   raw_input_fetcher_->StartMonitor();
  63 }
  64
  65 GamepadPlatformDataFetcherWin::~GamepadPlatformDataFetcherWin() {
  66   raw_input_fetcher_->StopMonitor();
  67 }
  68
  69 int GamepadPlatformDataFetcherWin::FirstAvailableGamepadId() const {
  70   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
  71     if (pad_state_[i].status == DISCONNECTED)
  72       return i;
  73   }
  74   return -1;
  75 }
  76
  77 bool GamepadPlatformDataFetcherWin::HasXInputGamepad(int index) const {
  78   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
  79     if (pad_state_[i].status == XINPUT_CONNECTED &&
  80         pad_state_[i].xinput_index == index)
  81       return true;
  82   }
  83   return false;
  84 }
  85
  86 bool GamepadPlatformDataFetcherWin::HasRawInputGamepad(
  87     const HANDLE handle) const {
  88   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
  89     if (pad_state_[i].status == RAWINPUT_CONNECTED &&
  90         pad_state_[i].raw_input_handle == handle)
  91       return true;
  92   }
  93   return false;
  94 }
  95
  96 void GamepadPlatformDataFetcherWin::EnumerateDevices(
  97     WebGamepads* pads) {
  98   TRACE_EVENT0("GAMEPAD", "EnumerateDevices");
  99
 100   // Mark all disconnected pads DISCONNECTED.
 101   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
 102     if (!pads->items[i].connected)
 103       pad_state_[i].status = DISCONNECTED;
 104   }
 105
 106   for (size_t i = 0; i < XUSER_MAX_COUNT; ++i) {
 107     if (HasXInputGamepad(i))
 108       continue;
 109     int pad_index = FirstAvailableGamepadId();
 110     if (pad_index == -1)
 111       return;  // We can't add any more gamepads.
 112     WebGamepad& pad = pads->items[pad_index];
 113     if (xinput_available_ && GetXInputPadConnectivity(i, &pad)) {
 114       pad_state_[pad_index].status = XINPUT_CONNECTED;
 115       pad_state_[pad_index].xinput_index = i;
 116       pad_state_[pad_index].mapper = NULL;
 117       pads->length++;
 118     }
 119   }
 120
 121   if (raw_input_fetcher_->Available()) {
 122     std::vector<RawGamepadInfo*> raw_inputs =
 123         raw_input_fetcher_->EnumerateDevices();
 124     for (size_t i = 0; i < raw_inputs.size(); ++i) {
 125       RawGamepadInfo* gamepad = raw_inputs[i];
 126       if (HasRawInputGamepad(gamepad->handle))
 127         continue;
 128       int pad_index = FirstAvailableGamepadId();
 129       if (pad_index == -1)
 130         return;
 131       WebGamepad& pad = pads->items[pad_index];
 132       pad.connected = true;
 133       PadState& state = pad_state_[pad_index];
 134       state.status = RAWINPUT_CONNECTED;
 135       state.raw_input_handle = gamepad->handle;
 136
 137       std::string vendor = base::StringPrintf("%04x", gamepad->vendor_id);
 138       std::string product = base::StringPrintf("%04x", gamepad->product_id);
 139       state.mapper = GetGamepadStandardMappingFunction(vendor, product);
 140
 141       swprintf(pad.id, WebGamepad::idLengthCap,
 142         L"%ls (%lsVendor: %04x Product: %04x)",
 143         gamepad->id, state.mapper ? L"STANDARD GAMEPAD " : L"",
 144         gamepad->vendor_id, gamepad->product_id);
 145
 146       if (state.mapper)
 147         swprintf(pad.mapping, WebGamepad::mappingLengthCap, L"standard");
 148       else
 149         pad.mapping[0] = 0;
 150
 151       pads->length++;
 152     }
 153   }
 154 }
 155
 156
 157 void GamepadPlatformDataFetcherWin::GetGamepadData(WebGamepads* pads,
 158                                                    bool devices_changed_hint) {
 159   TRACE_EVENT0("GAMEPAD", "GetGamepadData");
 160
 161   if (!xinput_available_ &&
 162       !raw_input_fetcher_->Available()) {
 163     pads->length = 0;
 164     return;
 165   }
 166
 167   // A note on XInput devices:
 168   // If we got notification that system devices have been updated, then
 169   // run GetCapabilities to update the connected status and the device
 170   // identifier. It can be slow to do to both GetCapabilities and
 171   // GetState on unconnected devices, so we want to avoid a 2-5ms pause
 172   // here by only doing this when the devices are updated (despite
 173   // documentation claiming it's OK to call it any time).
 174   if (devices_changed_hint)
 175     EnumerateDevices(pads);
 176
 177   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
 178     // We rely on device_changed and GetCapabilities to tell us that
 179     // something's been connected, but we will mark as disconnected if
 180     // Get___PadState returns that we've lost the pad.
 181     if (!pads->items[i].connected)
 182       continue;
 183
 184     if (pad_state_[i].status == XINPUT_CONNECTED)
 185       GetXInputPadData(i, &pads->items[i]);
 186     else if (pad_state_[i].status == RAWINPUT_CONNECTED)
 187       GetRawInputPadData(i, &pads->items[i]);
 188   }
 189 }
 190
 191 void GamepadPlatformDataFetcherWin::PauseHint(bool pause) {
 192   if (pause)
 193     raw_input_fetcher_->StopMonitor();
 194   else
 195     raw_input_fetcher_->StartMonitor();
 196 }
 197
 198 bool GamepadPlatformDataFetcherWin::GetXInputPadConnectivity(
 199     int i,
 200     WebGamepad* pad) const {
 201   DCHECK(pad);
 202   TRACE_EVENT1("GAMEPAD", "GetXInputPadConnectivity", "id", i);
 203   XINPUT_CAPABILITIES caps;
 204   DWORD res = xinput_get_capabilities_(i, XINPUT_FLAG_GAMEPAD, &caps);
 205   if (res == ERROR_DEVICE_NOT_CONNECTED) {
 206     pad->connected = false;
 207     return false;
 208   } else {
 209     pad->connected = true;
 210     swprintf(pad->id,
 211              WebGamepad::idLengthCap,
 212              L"Xbox 360 Controller (XInput STANDARD %ls)",
 213              GamepadSubTypeName(caps.SubType));
 214     swprintf(pad->mapping, WebGamepad::mappingLengthCap, L"standard");
 215     return true;
 216   }
 217 }
 218
 219 void GamepadPlatformDataFetcherWin::GetXInputPadData(
 220     int i,
 221     WebGamepad* pad) {
 222   XINPUT_STATE state;
 223   memset(&state, 0, sizeof(XINPUT_STATE));
 224   TRACE_EVENT_BEGIN1("GAMEPAD", "XInputGetState", "id", i);
 225   DWORD dwResult = xinput_get_state_(pad_state_[i].xinput_index, &state);
 226   TRACE_EVENT_END1("GAMEPAD", "XInputGetState", "id", i);
 227
 228   if (dwResult == ERROR_SUCCESS) {
 229     pad->timestamp = state.dwPacketNumber;
 230     pad->buttonsLength = 0;
 231 #define ADD(b) pad->buttons[pad->buttonsLength].pressed = \
 232   (state.Gamepad.wButtons & (b)) != 0; \
 233   pad->buttons[pad->buttonsLength++].value = \
 234   ((state.Gamepad.wButtons & (b)) ? 1.f : 0.f);
 235     ADD(XINPUT_GAMEPAD_A);
 236     ADD(XINPUT_GAMEPAD_B);
 237     ADD(XINPUT_GAMEPAD_X);
 238     ADD(XINPUT_GAMEPAD_Y);
 239     ADD(XINPUT_GAMEPAD_LEFT_SHOULDER);
 240     ADD(XINPUT_GAMEPAD_RIGHT_SHOULDER);
 241     pad->buttons[pad->buttonsLength].pressed =
 242         state.Gamepad.bLeftTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
 243     pad->buttons[pad->buttonsLength++].value =
 244         state.Gamepad.bLeftTrigger / 255.f;
 245     pad->buttons[pad->buttonsLength].pressed =
 246         state.Gamepad.bRightTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
 247     pad->buttons[pad->buttonsLength++].value =
 248         state.Gamepad.bRightTrigger / 255.f;
 249     ADD(XINPUT_GAMEPAD_BACK);
 250     ADD(XINPUT_GAMEPAD_START);
 251     ADD(XINPUT_GAMEPAD_LEFT_THUMB);
 252     ADD(XINPUT_GAMEPAD_RIGHT_THUMB);
 253     ADD(XINPUT_GAMEPAD_DPAD_UP);
 254     ADD(XINPUT_GAMEPAD_DPAD_DOWN);
 255     ADD(XINPUT_GAMEPAD_DPAD_LEFT);
 256     ADD(XINPUT_GAMEPAD_DPAD_RIGHT);
 257 #undef ADD
 258     pad->axesLength = 0;
 259     // XInput are +up/+right, -down/-left, we want -up/-left.
 260     pad->axes[pad->axesLength++] = NormalizeXInputAxis(state.Gamepad.sThumbLX);
 261     pad->axes[pad->axesLength++] = -NormalizeXInputAxis(state.Gamepad.sThumbLY);
 262     pad->axes[pad->axesLength++] = NormalizeXInputAxis(state.Gamepad.sThumbRX);
 263     pad->axes[pad->axesLength++] = -NormalizeXInputAxis(state.Gamepad.sThumbRY);
 264   } else {
 265     pad->connected = false;
 266   }
 267 }
 268
 269 void GamepadPlatformDataFetcherWin::GetRawInputPadData(
 270     int index,
 271     WebGamepad* pad) {
 272   RawGamepadInfo* gamepad = raw_input_fetcher_->GetGamepadInfo(
 273       pad_state_[index].raw_input_handle);
 274   if (!gamepad) {
 275     pad->connected = false;
 276     return;
 277   }
 278
 279   WebGamepad raw_pad = *pad;
 280
 281   raw_pad.timestamp = gamepad->report_id;
 282   raw_pad.buttonsLength = gamepad->buttons_length;
 283   raw_pad.axesLength =  gamepad->axes_length;
 284
 285   for (unsigned int i = 0; i < raw_pad.buttonsLength; i++) {
 286     raw_pad.buttons[i].pressed = gamepad->buttons[i];
 287     raw_pad.buttons[i].value = gamepad->buttons[i] ? 1.0 : 0.0;
 288   }
 289
 290   for (unsigned int i = 0; i < raw_pad.axesLength; i++)
 291     raw_pad.axes[i] = gamepad->axes[i].value;
 292
 293   // Copy to the current state to the output buffer, using the mapping
 294   // function, if there is one available.
 295   if (pad_state_[index].mapper)
 296     pad_state_[index].mapper(raw_pad, pad);
 297   else
 298     *pad = raw_pad;
 299 }
 300
 301 bool GamepadPlatformDataFetcherWin::GetXInputDllFunctions() {
 302   xinput_get_capabilities_ = NULL;
 303   xinput_get_state_ = NULL;
 304   xinput_enable_ = reinterpret_cast<XInputEnableFunc>(
 305       xinput_dll_.GetFunctionPointer("XInputEnable"));
 306   if (!xinput_enable_)
 307     return false;
 308   xinput_get_capabilities_ = reinterpret_cast<XInputGetCapabilitiesFunc>(
 309       xinput_dll_.GetFunctionPointer("XInputGetCapabilities"));
 310   if (!xinput_get_capabilities_)
 311     return false;
 312   xinput_get_state_ = reinterpret_cast<XInputGetStateFunc>(
 313       xinput_dll_.GetFunctionPointer("XInputGetState"));
 314   if (!xinput_get_state_)
 315     return false;
 316   xinput_enable_(true);
 317   return true;
 318 }
 319
 320 }  // namespace content