content/browser/gamepad/raw_input_data_fetcher_win.cc

   1 // Copyright 2014 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/raw_input_data_fetcher_win.h"
   6
   7 #include "base/trace_event/trace_event.h"
   8 #include "content/common/gamepad_hardware_buffer.h"
   9 #include "content/common/gamepad_messages.h"
  10
  11 namespace content {
  12
  13 using namespace blink;
  14
  15 namespace {
  16
  17 float NormalizeAxis(long value, long min, long max) {
  18   return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
  19 }
  20
  21 // From the HID Usage Tables specification.
  22 USHORT DeviceUsages[] = {
  23   0x04,  // Joysticks
  24   0x05,  // Gamepads
  25   0x08,  // Multi Axis
  26 };
  27
  28 const uint32_t kAxisMinimumUsageNumber = 0x30;
  29 const uint32_t kGameControlsUsagePage = 0x05;
  30
  31 }   // namespace
  32
  33 RawInputDataFetcher::RawInputDataFetcher()
  34     : hid_dll_(base::FilePath(FILE_PATH_LITERAL("hid.dll")))
  35     , rawinput_available_(GetHidDllFunctions())
  36     , filter_xinput_(true)
  37     , events_monitored_(false) {}
  38
  39 RawInputDataFetcher::~RawInputDataFetcher() {
  40   DCHECK(!window_);
  41   DCHECK(!events_monitored_);
  42 }
  43
  44 void RawInputDataFetcher::WillDestroyCurrentMessageLoop() {
  45   StopMonitor();
  46 }
  47
  48 RAWINPUTDEVICE* RawInputDataFetcher::GetRawInputDevices(DWORD flags) {
  49   int usage_count = arraysize(DeviceUsages);
  50   scoped_ptr<RAWINPUTDEVICE[]> devices(new RAWINPUTDEVICE[usage_count]);
  51   for (int i = 0; i < usage_count; ++i) {
  52     devices[i].dwFlags = flags;
  53     devices[i].usUsagePage = 1;
  54     devices[i].usUsage = DeviceUsages[i];
  55     devices[i].hwndTarget = window_->hwnd();
  56   }
  57   return devices.release();
  58 }
  59
  60 void RawInputDataFetcher::StartMonitor() {
  61   if (!rawinput_available_ || events_monitored_)
  62     return;
  63
  64   if (!window_) {
  65     window_.reset(new base::win::MessageWindow());
  66     if (!window_->Create(base::Bind(&RawInputDataFetcher::HandleMessage,
  67                                     base::Unretained(this)))) {
  68       PLOG(ERROR) << "Failed to create the raw input window";
  69       window_.reset();
  70       return;
  71     }
  72   }
  73
  74   // Register to receive raw HID input.
  75   scoped_ptr<RAWINPUTDEVICE[]> devices(GetRawInputDevices(RIDEV_INPUTSINK));
  76   if (!RegisterRawInputDevices(devices.get(), arraysize(DeviceUsages),
  77       sizeof(RAWINPUTDEVICE))) {
  78     PLOG(ERROR) << "RegisterRawInputDevices() failed for RIDEV_INPUTSINK";
  79     window_.reset();
  80     return;
  81   }
  82
  83   // Start observing message loop destruction if we start monitoring the first
  84   // event.
  85   if (!events_monitored_)
  86     base::MessageLoop::current()->AddDestructionObserver(this);
  87
  88   events_monitored_ = true;
  89 }
  90
  91 void RawInputDataFetcher::StopMonitor() {
  92   if (!rawinput_available_ || !events_monitored_)
  93     return;
  94
  95   // Stop receiving raw input.
  96   DCHECK(window_);
  97   scoped_ptr<RAWINPUTDEVICE[]> devices(GetRawInputDevices(RIDEV_REMOVE));
  98
  99   if (!RegisterRawInputDevices(devices.get(), arraysize(DeviceUsages),
 100       sizeof(RAWINPUTDEVICE))) {
 101     PLOG(INFO) << "RegisterRawInputDevices() failed for RIDEV_REMOVE";
 102   }
 103
 104   events_monitored_ = false;
 105   window_.reset();
 106   ClearControllers();
 107
 108   // Stop observing message loop destruction if no event is being monitored.
 109   base::MessageLoop::current()->RemoveDestructionObserver(this);
 110 }
 111
 112 void RawInputDataFetcher::ClearControllers() {
 113   while (!controllers_.empty()) {
 114     RawGamepadInfo* gamepad_info = controllers_.begin()->second;
 115     controllers_.erase(gamepad_info->handle);
 116     delete gamepad_info;
 117   }
 118 }
 119
 120 std::vector<RawGamepadInfo*> RawInputDataFetcher::EnumerateDevices() {
 121   std::vector<RawGamepadInfo*> valid_controllers;
 122
 123   ClearControllers();
 124
 125   UINT count = 0;
 126   UINT result = GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST));
 127   if (result == static_cast<UINT>(-1)) {
 128     PLOG(ERROR) << "GetRawInputDeviceList() failed";
 129     return valid_controllers;
 130   }
 131   DCHECK_EQ(0u, result);
 132
 133   scoped_ptr<RAWINPUTDEVICELIST[]> device_list(new RAWINPUTDEVICELIST[count]);
 134   result = GetRawInputDeviceList(device_list.get(), &count,
 135       sizeof(RAWINPUTDEVICELIST));
 136   if (result == static_cast<UINT>(-1)) {
 137     PLOG(ERROR) << "GetRawInputDeviceList() failed";
 138     return valid_controllers;
 139   }
 140   DCHECK_EQ(count, result);
 141
 142   for (UINT i = 0; i < count; ++i) {
 143     if (device_list[i].dwType == RIM_TYPEHID) {
 144       HANDLE device_handle = device_list[i].hDevice;
 145       RawGamepadInfo* gamepad_info = ParseGamepadInfo(device_handle);
 146       if (gamepad_info) {
 147         controllers_[device_handle] = gamepad_info;
 148         valid_controllers.push_back(gamepad_info);
 149       }
 150     }
 151   }
 152   return valid_controllers;
 153 }
 154
 155 RawGamepadInfo* RawInputDataFetcher::GetGamepadInfo(HANDLE handle) {
 156   std::map<HANDLE, RawGamepadInfo*>::iterator it = controllers_.find(handle);
 157   if (it != controllers_.end())
 158     return it->second;
 159
 160   return NULL;
 161 }
 162
 163 RawGamepadInfo* RawInputDataFetcher::ParseGamepadInfo(HANDLE hDevice) {
 164   UINT size = 0;
 165
 166   // Do we already have this device in the map?
 167   if (GetGamepadInfo(hDevice))
 168     return NULL;
 169
 170   // Query basic device info.
 171   UINT result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICEINFO,
 172       NULL, &size);
 173   if (result == static_cast<UINT>(-1)) {
 174     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 175     return NULL;
 176   }
 177   DCHECK_EQ(0u, result);
 178
 179   scoped_ptr<uint8[]> di_buffer(new uint8[size]);
 180   RID_DEVICE_INFO* device_info =
 181       reinterpret_cast<RID_DEVICE_INFO*>(di_buffer.get());
 182   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICEINFO,
 183       di_buffer.get(), &size);
 184   if (result == static_cast<UINT>(-1)) {
 185     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 186     return NULL;
 187   }
 188   DCHECK_EQ(size, result);
 189
 190   // Make sure this device is of a type that we want to observe.
 191   bool valid_type = false;
 192   for (int i = 0; i < arraysize(DeviceUsages); ++i) {
 193     if (device_info->hid.usUsage == DeviceUsages[i]) {
 194       valid_type = true;
 195       break;
 196     }
 197   }
 198
 199   if (!valid_type)
 200     return NULL;
 201
 202   scoped_ptr<RawGamepadInfo> gamepad_info(new RawGamepadInfo);
 203   gamepad_info->handle = hDevice;
 204   gamepad_info->report_id = 0;
 205   gamepad_info->vendor_id = device_info->hid.dwVendorId;
 206   gamepad_info->product_id = device_info->hid.dwProductId;
 207   gamepad_info->buttons_length = 0;
 208   ZeroMemory(gamepad_info->buttons, sizeof(gamepad_info->buttons));
 209   gamepad_info->axes_length = 0;
 210   ZeroMemory(gamepad_info->axes, sizeof(gamepad_info->axes));
 211
 212   // Query device identifier
 213   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICENAME,
 214       NULL, &size);
 215   if (result == static_cast<UINT>(-1)) {
 216     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 217     return NULL;
 218   }
 219   DCHECK_EQ(0u, result);
 220
 221   scoped_ptr<wchar_t[]> name_buffer(new wchar_t[size]);
 222   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICENAME,
 223       name_buffer.get(), &size);
 224   if (result == static_cast<UINT>(-1)) {
 225     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 226     return NULL;
 227   }
 228   DCHECK_EQ(size, result);
 229
 230   // The presence of "IG_" in the device name indicates that this is an XInput
 231   // Gamepad. Skip enumerating these devices and let the XInput path handle it.
 232   // http://msdn.microsoft.com/en-us/library/windows/desktop/ee417014.aspx
 233   if (filter_xinput_ && wcsstr( name_buffer.get(), L"IG_" ) )
 234     return NULL;
 235
 236   // Get a friendly device name
 237   BOOLEAN got_product_string = FALSE;
 238   HANDLE hid_handle = CreateFile(name_buffer.get(), GENERIC_READ|GENERIC_WRITE,
 239       FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
 240   if (hid_handle) {
 241     got_product_string = hidd_get_product_string_(hid_handle, gamepad_info->id,
 242         sizeof(gamepad_info->id));
 243     CloseHandle(hid_handle);
 244   }
 245
 246   if (!got_product_string)
 247     swprintf(gamepad_info->id, WebGamepad::idLengthCap, L"Unknown Gamepad");
 248
 249   // Query device capabilities.
 250   result = GetRawInputDeviceInfo(hDevice, RIDI_PREPARSEDDATA,
 251       NULL, &size);
 252   if (result == static_cast<UINT>(-1)) {
 253     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 254     return NULL;
 255   }
 256   DCHECK_EQ(0u, result);
 257
 258   gamepad_info->ppd_buffer.reset(new uint8[size]);
 259   gamepad_info->preparsed_data =
 260       reinterpret_cast<PHIDP_PREPARSED_DATA>(gamepad_info->ppd_buffer.get());
 261   result = GetRawInputDeviceInfo(hDevice, RIDI_PREPARSEDDATA,
 262        gamepad_info->ppd_buffer.get(), &size);
 263   if (result == static_cast<UINT>(-1)) {
 264     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
 265     return NULL;
 266   }
 267   DCHECK_EQ(size, result);
 268
 269   HIDP_CAPS caps;
 270   NTSTATUS status = hidp_get_caps_(gamepad_info->preparsed_data, &caps);
 271   DCHECK_EQ(HIDP_STATUS_SUCCESS, status);
 272
 273   // Query button information.
 274   USHORT count = caps.NumberInputButtonCaps;
 275   if (count > 0) {
 276     scoped_ptr<HIDP_BUTTON_CAPS[]> button_caps(new HIDP_BUTTON_CAPS[count]);
 277     status = hidp_get_button_caps_(
 278         HidP_Input, button_caps.get(), &count, gamepad_info->preparsed_data);
 279     DCHECK_EQ(HIDP_STATUS_SUCCESS, status);
 280
 281     for (uint32_t i = 0; i < count; ++i) {
 282       if (button_caps[i].Range.UsageMin <= WebGamepad::buttonsLengthCap) {
 283         uint32_t max_index =
 284             std::min(WebGamepad::buttonsLengthCap,
 285                      static_cast<size_t>(button_caps[i].Range.UsageMax));
 286         gamepad_info->buttons_length = std::max(
 287             gamepad_info->buttons_length, max_index);
 288       }
 289     }
 290   }
 291
 292   // Query axis information.
 293   count = caps.NumberInputValueCaps;
 294   scoped_ptr<HIDP_VALUE_CAPS[]> axes_caps(new HIDP_VALUE_CAPS[count]);
 295   status = hidp_get_value_caps_(HidP_Input, axes_caps.get(), &count,
 296       gamepad_info->preparsed_data);
 297
 298   bool mapped_all_axes = true;
 299
 300   for (UINT i = 0; i < count; i++) {
 301     uint32_t axis_index = axes_caps[i].Range.UsageMin - kAxisMinimumUsageNumber;
 302     if (axis_index < WebGamepad::axesLengthCap) {
 303       gamepad_info->axes[axis_index].caps = axes_caps[i];
 304       gamepad_info->axes[axis_index].value = 0;
 305       gamepad_info->axes[axis_index].active = true;
 306       gamepad_info->axes_length =
 307           std::max(gamepad_info->axes_length, axis_index + 1);
 308     } else {
 309       mapped_all_axes = false;
 310     }
 311   }
 312
 313   if (!mapped_all_axes) {
 314     // For axes who's usage puts them outside the standard axesLengthCap range.
 315     uint32_t next_index = 0;
 316     for (UINT i = 0; i < count; i++) {
 317       uint32_t usage = axes_caps[i].Range.UsageMin - kAxisMinimumUsageNumber;
 318       if (usage >= WebGamepad::axesLengthCap &&
 319           axes_caps[i].UsagePage <= kGameControlsUsagePage) {
 320
 321         for (; next_index < WebGamepad::axesLengthCap; ++next_index) {
 322           if (!gamepad_info->axes[next_index].active)
 323             break;
 324         }
 325         if (next_index < WebGamepad::axesLengthCap) {
 326           gamepad_info->axes[next_index].caps = axes_caps[i];
 327           gamepad_info->axes[next_index].value = 0;
 328           gamepad_info->axes[next_index].active = true;
 329           gamepad_info->axes_length =
 330               std::max(gamepad_info->axes_length, next_index + 1);
 331         }
 332       }
 333
 334       if (next_index >= WebGamepad::axesLengthCap)
 335         break;
 336     }
 337   }
 338
 339   return gamepad_info.release();
 340 }
 341
 342 void RawInputDataFetcher::UpdateGamepad(
 343     RAWINPUT* input,
 344     RawGamepadInfo* gamepad_info) {
 345   NTSTATUS status;
 346
 347   gamepad_info->report_id++;
 348
 349   // Query button state.
 350   if (gamepad_info->buttons_length) {
 351     // Clear the button state
 352     ZeroMemory(gamepad_info->buttons, sizeof(gamepad_info->buttons));
 353     ULONG buttons_length = 0;
 354
 355     hidp_get_usages_ex_(HidP_Input,
 356                         0,
 357                         NULL,
 358                         &buttons_length,
 359                         gamepad_info->preparsed_data,
 360                         reinterpret_cast<PCHAR>(input->data.hid.bRawData),
 361                         input->data.hid.dwSizeHid);
 362
 363     scoped_ptr<USAGE_AND_PAGE[]> usages(new USAGE_AND_PAGE[buttons_length]);
 364     status =
 365         hidp_get_usages_ex_(HidP_Input,
 366                             0,
 367                             usages.get(),
 368                             &buttons_length,
 369                             gamepad_info->preparsed_data,
 370                             reinterpret_cast<PCHAR>(input->data.hid.bRawData),
 371                             input->data.hid.dwSizeHid);
 372
 373     if (status == HIDP_STATUS_SUCCESS) {
 374       // Set each reported button to true.
 375       for (uint32_t j = 0; j < buttons_length; j++) {
 376         int32_t button_index = usages[j].Usage - 1;
 377         if (button_index >= 0 &&
 378             button_index < blink::WebGamepad::buttonsLengthCap)
 379           gamepad_info->buttons[button_index] = true;
 380       }
 381     }
 382   }
 383
 384   // Query axis state.
 385   ULONG axis_value = 0;
 386   LONG scaled_axis_value = 0;
 387   for (uint32_t i = 0; i < gamepad_info->axes_length; i++) {
 388     RawGamepadAxis* axis = &gamepad_info->axes[i];
 389
 390     // If the min is < 0 we have to query the scaled value, otherwise we need
 391     // the normal unscaled value.
 392     if (axis->caps.LogicalMin < 0) {
 393       status = hidp_get_scaled_usage_value_(HidP_Input, axis->caps.UsagePage, 0,
 394           axis->caps.Range.UsageMin, &scaled_axis_value,
 395           gamepad_info->preparsed_data,
 396           reinterpret_cast<PCHAR>(input->data.hid.bRawData),
 397           input->data.hid.dwSizeHid);
 398       if (status == HIDP_STATUS_SUCCESS) {
 399         axis->value = NormalizeAxis(scaled_axis_value,
 400             axis->caps.LogicalMin, axis->caps.LogicalMax);
 401       }
 402     } else {
 403       status = hidp_get_usage_value_(HidP_Input, axis->caps.UsagePage, 0,
 404           axis->caps.Range.UsageMin, &axis_value,
 405           gamepad_info->preparsed_data,
 406           reinterpret_cast<PCHAR>(input->data.hid.bRawData),
 407           input->data.hid.dwSizeHid);
 408       if (status == HIDP_STATUS_SUCCESS) {
 409         axis->value = NormalizeAxis(axis_value,
 410             axis->caps.LogicalMin, axis->caps.LogicalMax);
 411       }
 412     }
 413   }
 414 }
 415
 416 LRESULT RawInputDataFetcher::OnInput(HRAWINPUT input_handle) {
 417   // Get the size of the input record.
 418   UINT size = 0;
 419   UINT result = GetRawInputData(
 420       input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
 421   if (result == static_cast<UINT>(-1)) {
 422     PLOG(ERROR) << "GetRawInputData() failed";
 423     return 0;
 424   }
 425   DCHECK_EQ(0u, result);
 426
 427   // Retrieve the input record.
 428   scoped_ptr<uint8[]> buffer(new uint8[size]);
 429   RAWINPUT* input = reinterpret_cast<RAWINPUT*>(buffer.get());
 430   result = GetRawInputData(
 431       input_handle, RID_INPUT, buffer.get(), &size, sizeof(RAWINPUTHEADER));
 432   if (result == static_cast<UINT>(-1)) {
 433     PLOG(ERROR) << "GetRawInputData() failed";
 434     return 0;
 435   }
 436   DCHECK_EQ(size, result);
 437
 438   // Notify the observer about events generated locally.
 439   if (input->header.dwType == RIM_TYPEHID && input->header.hDevice != NULL) {
 440     RawGamepadInfo* gamepad = GetGamepadInfo(input->header.hDevice);
 441     if (gamepad)
 442       UpdateGamepad(input, gamepad);
 443   }
 444
 445   return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
 446 }
 447
 448 bool RawInputDataFetcher::HandleMessage(UINT message,
 449                                             WPARAM wparam,
 450                                             LPARAM lparam,
 451                                             LRESULT* result) {
 452   switch (message) {
 453     case WM_INPUT:
 454       *result = OnInput(reinterpret_cast<HRAWINPUT>(lparam));
 455       return true;
 456
 457     default:
 458       return false;
 459   }
 460 }
 461
 462 bool RawInputDataFetcher::GetHidDllFunctions() {
 463   hidp_get_caps_ = NULL;
 464   hidp_get_button_caps_ = NULL;
 465   hidp_get_value_caps_ = NULL;
 466   hidp_get_usages_ex_ = NULL;
 467   hidp_get_usage_value_ = NULL;
 468   hidp_get_scaled_usage_value_ = NULL;
 469   hidd_get_product_string_ = NULL;
 470
 471   if (!hid_dll_.is_valid()) return false;
 472
 473   hidp_get_caps_ = reinterpret_cast<HidPGetCapsFunc>(
 474       hid_dll_.GetFunctionPointer("HidP_GetCaps"));
 475   if (!hidp_get_caps_)
 476     return false;
 477   hidp_get_button_caps_ = reinterpret_cast<HidPGetButtonCapsFunc>(
 478       hid_dll_.GetFunctionPointer("HidP_GetButtonCaps"));
 479   if (!hidp_get_button_caps_)
 480     return false;
 481   hidp_get_value_caps_ = reinterpret_cast<HidPGetValueCapsFunc>(
 482       hid_dll_.GetFunctionPointer("HidP_GetValueCaps"));
 483   if (!hidp_get_value_caps_)
 484     return false;
 485   hidp_get_usages_ex_ = reinterpret_cast<HidPGetUsagesExFunc>(
 486       hid_dll_.GetFunctionPointer("HidP_GetUsagesEx"));
 487   if (!hidp_get_usages_ex_)
 488     return false;
 489   hidp_get_usage_value_ = reinterpret_cast<HidPGetUsageValueFunc>(
 490       hid_dll_.GetFunctionPointer("HidP_GetUsageValue"));
 491   if (!hidp_get_usage_value_)
 492     return false;
 493   hidp_get_scaled_usage_value_ = reinterpret_cast<HidPGetScaledUsageValueFunc>(
 494       hid_dll_.GetFunctionPointer("HidP_GetScaledUsageValue"));
 495   if (!hidp_get_scaled_usage_value_)
 496     return false;
 497   hidd_get_product_string_ = reinterpret_cast<HidDGetStringFunc>(
 498       hid_dll_.GetFunctionPointer("HidD_GetProductString"));
 499   if (!hidd_get_product_string_)
 500     return false;
 501
 502   return true;
 503 }
 504
 505 }  // namespace content