ControllerDeviceEnumerator::ControllerDeviceEnumerator(CommonDeviceState::eDeviceType deviceType)
: DeviceEnumerator(deviceType)
, devs(nullptr)
, cur_dev(nullptr)
{
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CONTROLLER_TYPE_INDEX);
USBDeviceInfo &dev_info = g_supported_controller_infos[GET_DEVICE_TYPE_INDEX(m_deviceType)];
devs = hid_enumerate(dev_info.vendor_id, dev_info.product_id);
cur_dev = devs;
if (!is_valid())
{
next();
}
}
TrackerDeviceEnumerator::TrackerDeviceEnumerator(CommonDeviceState::eDeviceType deviceType)
: DeviceEnumerator(deviceType)
, devs(nullptr)
, cur_dev(nullptr)
, dev_index(0)
, dev_count(0)
, camera_index(-1)
, dev_valid(false)
{
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CAMERA_TYPE_INDEX);
memset(dev_port_numbers, 255, sizeof(dev_port_numbers));
libusb_init(&usb_context);
dev_count = static_cast<int>(libusb_get_device_list(usb_context, &devs));
cur_dev = (devs != nullptr) ? devs[0] : nullptr;
if (!is_valid())
{
camera_index = -1;
next();
}
else
{
camera_index = 0;
}
}
// -- methods -----
TrackerDeviceEnumerator::TrackerDeviceEnumerator()
: DeviceEnumerator(CommonDeviceState::PS3EYE)
, usb_context(nullptr)
, devs(nullptr)
, cur_dev(nullptr)
, dev_index(0)
, dev_count(0)
, camera_index(-1)
{
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CAMERA_TYPE_INDEX);
libusb_init(&usb_context);
dev_count = static_cast<int>(libusb_get_device_list(usb_context, &devs));
cur_dev = (devs != nullptr) ? devs[0] : nullptr;
camera_index = 0;
if (!recompute_current_device_validity())
{
camera_index = -1;
next();
}
else
{
camera_index = 0;
}
}
void HMDDeviceEnumerator::build_interface_list()
{
USBDeviceInfo &dev_info = g_supported_hmd_infos[GET_DEVICE_TYPE_INDEX(m_deviceType)];
hid_device_info * devs = hid_enumerate(dev_info.vendor_id, dev_info.product_id);
current_device_identifier = "";
current_device_interfaces.clear();
if (devs != nullptr)
{
std::stringstream device_id_builder;
device_id_builder <<
"USB\\VID_" << std::hex << std::setfill('0') << std::setw(4) << dev_info.vendor_id <<
"&PID_" << std::hex << std::setfill('0') << std::setw(4) << dev_info.product_id;
current_device_identifier = device_id_builder.str();
for (hid_device_info *cur_dev = devs; cur_dev != nullptr; cur_dev = cur_dev->next)
{
HMDDeviceInterface hmd_interface;
hmd_interface.device_path = cur_dev->path;
hmd_interface.interface_number = cur_dev->interface_number;
current_device_interfaces.push_back(hmd_interface);
}
hid_free_enumeration(devs);
}
}
// -- ControllerGamepadEnumerator -----
ControllerGamepadEnumerator::ControllerGamepadEnumerator()
: DeviceEnumerator()
, m_controllerIndex(-1)
{
m_deviceType= CommonDeviceState::PSMove;
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CONTROLLER_TYPE_INDEX);
Gamepad_detectDevices();
next();
}
ControllerGamepadEnumerator::ControllerGamepadEnumerator(
CommonDeviceState::eDeviceType deviceTypeFilter)
: DeviceEnumerator(deviceTypeFilter)
, m_controllerIndex(-1)
{
m_deviceType= deviceTypeFilter;
m_deviceTypeFilter= deviceTypeFilter;
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CONTROLLER_TYPE_INDEX);
Gamepad_detectDevices();
next();
}
HMDDeviceEnumerator::HMDDeviceEnumerator(CommonDeviceState::eDeviceType deviceType)
: DeviceEnumerator(deviceType)
{
assert(m_deviceType >= 0 && GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_HMD_TYPE_INDEX);
build_interface_list();
if (!is_valid())
{
next();
}
}
bool ControllerDeviceEnumerator::next()
{
bool foundValid = false;
while (!foundValid && m_deviceType < CommonDeviceState::SUPPORTED_CONTROLLER_TYPE_COUNT)
{
if (cur_dev != nullptr)
{
cur_dev = cur_dev->next;
foundValid = is_valid();
}
// If there are more device types to scan
// move on to the next vid/pid device enumeration
if (!foundValid && cur_dev == nullptr)
{
m_deviceType = static_cast<CommonDeviceState::eDeviceType>(m_deviceType + 1);
// Free any previous enumeration
if (devs != nullptr)
{
hid_free_enumeration(devs);
cur_dev= nullptr;
devs= nullptr;
}
if (GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_CONTROLLER_TYPE_INDEX)
{
USBDeviceInfo &dev_info = g_supported_controller_infos[GET_DEVICE_TYPE_INDEX(m_deviceType)];
// Create a new HID enumeration
devs = hid_enumerate(dev_info.vendor_id, dev_info.product_id);
cur_dev = devs;
foundValid = is_valid();
}
}
}
return foundValid;
}
bool TrackerDeviceEnumerator::recompute_current_device_validity()
{
dev_valid = false;
if (cur_dev != nullptr)
{
USBDeviceInfo &dev_info = g_supported_tracker_infos[GET_DEVICE_TYPE_INDEX(m_deviceType)];
struct libusb_device_descriptor dev_desc;
int libusb_result = libusb_get_device_descriptor(cur_dev, &dev_desc);
if (libusb_result == 0 &&
dev_desc.idVendor == dev_info.vendor_id &&
dev_desc.idProduct == dev_info.product_id)
{
uint8_t port_numbers[MAX_USB_DEVICE_PORT_PATH];
memset(port_numbers, 0, sizeof(port_numbers));
int elements_filled= libusb_get_port_numbers(cur_dev, port_numbers, MAX_USB_DEVICE_PORT_PATH);
if (elements_filled > 0)
{
// Make sure this device is actually different from the last device we looked at
// (i.e. has a different device port path)
if (memcmp(port_numbers, dev_port_numbers, sizeof(port_numbers)) != 0)
{
libusb_device_handle *devhandle;
// Finally need to test that we can actually open the device
// (or see that device is already open)
libusb_result = libusb_open(cur_dev, &devhandle);
if (libusb_result == LIBUSB_SUCCESS || libusb_result == LIBUSB_ERROR_ACCESS)
{
if (libusb_result == LIBUSB_SUCCESS)
{
libusb_close(devhandle);
}
// Cache the port number for the last valid device found
memcpy(dev_port_numbers, port_numbers, sizeof(port_numbers));
dev_valid = true;
}
}
}
}
}
return dev_valid;
}
bool HMDDeviceEnumerator::next()
{
bool foundValid = false;
while (!foundValid && m_deviceType < CommonDeviceState::SUPPORTED_HMD_TYPE_COUNT)
{
m_deviceType = static_cast<CommonDeviceState::eDeviceType>(m_deviceType + 1);
if (GET_DEVICE_TYPE_INDEX(m_deviceType) < MAX_HMD_TYPE_INDEX)
{
build_interface_list();
foundValid = is_valid();
}
else
{
current_device_identifier = "";
current_device_interfaces.clear();
}
}
return foundValid;
}
