From 0248614add99c1df1bc7c9ff97091f678ff75aca Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 12:36:28 -0400 Subject: GC Adapter Implementation --- src/input_common/gcadapter/gc_adapter.cpp | 350 ++++++++++++++++++++++++++++++ 1 file changed, 350 insertions(+) create mode 100644 src/input_common/gcadapter/gc_adapter.cpp (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp new file mode 100644 index 000000000..d42261d61 --- /dev/null +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -0,0 +1,350 @@ +// Copyright 2014 Dolphin Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. +//* +#include "common/logging/log.h" +#include "common/threadsafe_queue.h" +#include "input_common/gcadapter/gc_adapter.h" + +Common::SPSCQueue pad_queue[4]; +struct GCState state[4]; + +namespace GCAdapter { + +static libusb_device_handle* usb_adapter_handle = nullptr; +static u8 adapter_controllers_status[4] = { + ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE, + ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE}; + +static std::mutex s_mutex; + +static std::thread adapter_input_thread; +static bool adapter_thread_running; + +static std::mutex initialization_mutex; +static std::thread detect_thread; +static bool detect_thread_running = false; + +static libusb_context* libusb_ctx; + +static u8 input_endpoint = 0; + +static bool configuring = false; + +GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) { + GCPadStatus pad = {}; + bool get_origin = false; + + u8 type = adapter_payload[1 + (9 * port)] >> 4; + if (type) + get_origin = true; + + adapter_controllers_status[port] = type; + + if (adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE) { + u8 b1 = adapter_payload[1 + (9 * port) + 1]; + u8 b2 = adapter_payload[1 + (9 * port) + 2]; + + if (b1 & (1 << 0)) + pad.button |= PAD_BUTTON_A; + if (b1 & (1 << 1)) + pad.button |= PAD_BUTTON_B; + if (b1 & (1 << 2)) + pad.button |= PAD_BUTTON_X; + if (b1 & (1 << 3)) + pad.button |= PAD_BUTTON_Y; + + if (b1 & (1 << 4)) + pad.button |= PAD_BUTTON_LEFT; + if (b1 & (1 << 5)) + pad.button |= PAD_BUTTON_RIGHT; + if (b1 & (1 << 6)) + pad.button |= PAD_BUTTON_DOWN; + if (b1 & (1 << 7)) + pad.button |= PAD_BUTTON_UP; + + if (b2 & (1 << 0)) + pad.button |= PAD_BUTTON_START; + if (b2 & (1 << 1)) + pad.button |= PAD_TRIGGER_Z; + if (b2 & (1 << 2)) + pad.button |= PAD_TRIGGER_R; + if (b2 & (1 << 3)) + pad.button |= PAD_TRIGGER_L; + + if (get_origin) + pad.button |= PAD_GET_ORIGIN; + + pad.stickX = adapter_payload[1 + (9 * port) + 3]; + pad.stickY = adapter_payload[1 + (9 * port) + 4]; + pad.substickX = adapter_payload[1 + (9 * port) + 5]; + pad.substickY = adapter_payload[1 + (9 * port) + 6]; + pad.triggerLeft = adapter_payload[1 + (9 * port) + 7]; + pad.triggerRight = adapter_payload[1 + (9 * port) + 8]; + } + return pad; +} + +void PadToState(GCPadStatus pad, GCState& state) { + //std::lock_guard lock{s_mutex}; + state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A); + state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B); + state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X); + state.buttons.insert_or_assign(PAD_BUTTON_Y, pad.button & PAD_BUTTON_Y); + state.buttons.insert_or_assign(PAD_BUTTON_LEFT, pad.button & PAD_BUTTON_LEFT); + state.buttons.insert_or_assign(PAD_BUTTON_RIGHT, pad.button & PAD_BUTTON_RIGHT); + state.buttons.insert_or_assign(PAD_BUTTON_DOWN, pad.button & PAD_BUTTON_DOWN); + state.buttons.insert_or_assign(PAD_BUTTON_UP, pad.button & PAD_BUTTON_UP); + state.buttons.insert_or_assign(PAD_BUTTON_START, pad.button & PAD_BUTTON_START); + state.buttons.insert_or_assign(PAD_TRIGGER_Z, pad.button & PAD_TRIGGER_Z); + state.buttons.insert_or_assign(PAD_TRIGGER_L, pad.button & PAD_TRIGGER_L); + state.buttons.insert_or_assign(PAD_TRIGGER_R, pad.button & PAD_TRIGGER_R); + state.axes.insert_or_assign(STICK_X, pad.stickX); + state.axes.insert_or_assign(STICK_Y, pad.stickY); + state.axes.insert_or_assign(SUBSTICK_X, pad.substickX); + state.axes.insert_or_assign(SUBSTICK_Y, pad.substickY); + state.axes.insert_or_assign(TRIGGER_LEFT, pad.triggerLeft); + state.axes.insert_or_assign(TRIGGER_RIGHT, pad.triggerRight); +} + +static void Read() { + LOG_INFO(Input, "GC Adapter Read() thread started"); + + int payload_size_in; + u8 adapter_payload[37]; + while (adapter_thread_running) { + libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload, + sizeof(adapter_payload), &payload_size_in, 32); + + int payload_size = 0; + u8 controller_payload_copy[37]; + + { + std::lock_guard lk(s_mutex); + std::copy(std::begin(adapter_payload), std::end(adapter_payload), + std::begin(controller_payload_copy)); + payload_size = payload_size_in; + } + + GCPadStatus pad[4]; + if (payload_size != sizeof(controller_payload_copy) || + controller_payload_copy[0] != LIBUSB_DT_HID) { + LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, + controller_payload_copy[0]); + } else { + for (int i = 0; i < 4; i++) + pad[i] = CheckStatus(i, controller_payload_copy); + } + for (int port = 0; port < 4; port++) { + if (DeviceConnected(port) && configuring) { + if (pad[port].button != PAD_GET_ORIGIN) + pad_queue[port].Push(pad[port]); + + // Accounting for a threshold here because of some controller variance + if (pad[port].stickX > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD || + pad[port].stickX < pad[port].MAIN_STICK_CENTER_X - pad[port].THRESHOLD) { + pad[port].axis_which = STICK_X; + pad[port].axis_value = pad[port].stickX; + pad_queue[port].Push(pad[port]); + } + if (pad[port].stickY > pad[port].MAIN_STICK_CENTER_Y + pad[port].THRESHOLD || + pad[port].stickY < pad[port].MAIN_STICK_CENTER_Y - pad[port].THRESHOLD) { + pad[port].axis_which = STICK_Y; + pad[port].axis_value = pad[port].stickY; + pad_queue[port].Push(pad[port]); + } + if (pad[port].substickX > pad[port].C_STICK_CENTER_X + pad[port].THRESHOLD || + pad[port].substickX < pad[port].C_STICK_CENTER_X - pad[port].THRESHOLD) { + pad[port].axis_which = SUBSTICK_X; + pad[port].axis_value = pad[port].substickX; + pad_queue[port].Push(pad[port]); + } + if (pad[port].substickY > pad[port].C_STICK_CENTER_Y + pad[port].THRESHOLD || + pad[port].substickY < pad[port].C_STICK_CENTER_Y - pad[port].THRESHOLD) { + pad[port].axis_which = SUBSTICK_Y; + pad[port].axis_value = pad[port].substickY; + pad_queue[port].Push(pad[port]); + } + } + PadToState(pad[port], state[port]); + } + std::this_thread::yield(); + } +} + +static void ScanThreadFunc() { + LOG_INFO(Input, "GC Adapter scanning thread started"); + + while (detect_thread_running) { + if (usb_adapter_handle == nullptr) { + std::lock_guard lk(initialization_mutex); + Setup(); + } + Sleep(500); + } +} + +void Init() { + + if (usb_adapter_handle != nullptr) + return; + LOG_INFO(Input, "GC Adapter Initialization started"); + + current_status = NO_ADAPTER_DETECTED; + libusb_init(&libusb_ctx); + + StartScanThread(); +} + +void StartScanThread() { + if (detect_thread_running) + return; + if (!libusb_ctx) + return; + + detect_thread_running = true; + detect_thread = std::thread(ScanThreadFunc); +} + +void StopScanThread() { + detect_thread.join(); +} + +static void Setup() { + // Reset the error status in case the adapter gets unplugged + if (current_status < 0) + current_status = NO_ADAPTER_DETECTED; + + for (int i = 0; i < 4; i++) + adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; + + libusb_device** devs; // pointer to list of connected usb devices + + int cnt = libusb_get_device_list(libusb_ctx, &devs); //get the list of devices + + for (int i = 0; i < cnt; i++) { + if (CheckDeviceAccess(devs[i])) { + // GC Adapter found, registering it + GetGCEndpoint(devs[i]); + break; + } + } +} + +static bool CheckDeviceAccess(libusb_device* device) { + libusb_device_descriptor desc; + int ret = libusb_get_device_descriptor(device, &desc); + if (ret) { + // could not acquire the descriptor, no point in trying to use it. + LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: %d", ret); + return false; + } + + if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) { + // This isn’t the device we are looking for. + return false; + } + ret = libusb_open(device, &usb_adapter_handle); + + if (ret == LIBUSB_ERROR_ACCESS) { + LOG_ERROR(Input, + "Yuzu can not gain access to this device: ID %04X:%04X.", + desc.idVendor, desc.idProduct); + return false; + } + if (ret) { + LOG_ERROR(Input, "libusb_open failed to open device with error = %d", ret); + return false; + } + + ret = libusb_kernel_driver_active(usb_adapter_handle, 0); + if (ret == 1) { + ret = libusb_detach_kernel_driver(usb_adapter_handle, 0); + if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) + LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", ret); + } + + if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) { + libusb_close(usb_adapter_handle); + usb_adapter_handle = nullptr; + return false; + } + + ret = libusb_claim_interface(usb_adapter_handle, 0); + if (ret) { + LOG_ERROR(Input, "libusb_claim_interface failed with error = %d", ret); + libusb_close(usb_adapter_handle); + usb_adapter_handle = nullptr; + return false; + } + + return true; +} + +static void GetGCEndpoint(libusb_device* device) { + libusb_config_descriptor* config = nullptr; + libusb_get_config_descriptor(device, 0, &config); + for (u8 ic = 0; ic < config->bNumInterfaces; ic++) { + const libusb_interface* interfaceContainer = &config->interface[ic]; + for (int i = 0; i < interfaceContainer->num_altsetting; i++) { + const libusb_interface_descriptor* interface = &interfaceContainer->altsetting[i]; + for (u8 e = 0; e < interface->bNumEndpoints; e++) { + const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e]; + if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) + input_endpoint = endpoint->bEndpointAddress; + } + } + } + + adapter_thread_running = true; + current_status = ADAPTER_DETECTED; + + adapter_input_thread = std::thread(Read); // Read input +} + +void Shutdown() { + StopScanThread(); + Reset(); + + current_status = NO_ADAPTER_DETECTED; +} + +static void Reset() { + std::unique_lock lock(initialization_mutex, std::defer_lock); + if (!lock.try_lock()) + return; + if (current_status != ADAPTER_DETECTED) + return; + + if (adapter_thread_running) + adapter_input_thread.join(); + + for (int i = 0; i < 4; i++) + adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; + + current_status = NO_ADAPTER_DETECTED; + + if (usb_adapter_handle) { + libusb_release_interface(usb_adapter_handle, 0); + libusb_close(usb_adapter_handle); + usb_adapter_handle = nullptr; + } +} + +bool DeviceConnected(int port) { + return adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE; +} + +void ResetDeviceType(int port) { + adapter_controllers_status[port] = ControllerTypes::CONTROLLER_NONE; +} + +void BeginConfiguration() { + configuring = true; +} + +void EndConfiguration() { + configuring = false; +} + +} // end of namespace GCAdapter -- cgit v1.2.3 From c94583d867fd909d8731ba50e085352aae0e6885 Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 15:31:57 -0400 Subject: Clang Formatting --- src/input_common/gcadapter/gc_adapter.cpp | 90 +++++++++++++++++++------------ 1 file changed, 57 insertions(+), 33 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index d42261d61..dc04116ce 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -1,7 +1,7 @@ // Copyright 2014 Dolphin Emulator Project // Licensed under GPLv2+ // Refer to the license.txt file included. -//* + #include "common/logging/log.h" #include "common/threadsafe_queue.h" #include "input_common/gcadapter/gc_adapter.h" @@ -45,35 +45,48 @@ GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) { u8 b1 = adapter_payload[1 + (9 * port) + 1]; u8 b2 = adapter_payload[1 + (9 * port) + 2]; - if (b1 & (1 << 0)) + if (b1 & (1 << 0)) { pad.button |= PAD_BUTTON_A; - if (b1 & (1 << 1)) + } + if (b1 & (1 << 1)) { pad.button |= PAD_BUTTON_B; - if (b1 & (1 << 2)) + } + if (b1 & (1 << 2)) { pad.button |= PAD_BUTTON_X; - if (b1 & (1 << 3)) + } + if (b1 & (1 << 3)) { pad.button |= PAD_BUTTON_Y; + } - if (b1 & (1 << 4)) + if (b1 & (1 << 4)) { pad.button |= PAD_BUTTON_LEFT; - if (b1 & (1 << 5)) + } + if (b1 & (1 << 5)) { pad.button |= PAD_BUTTON_RIGHT; - if (b1 & (1 << 6)) + } + if (b1 & (1 << 6)) { pad.button |= PAD_BUTTON_DOWN; - if (b1 & (1 << 7)) + } + if (b1 & (1 << 7)) { pad.button |= PAD_BUTTON_UP; + } - if (b2 & (1 << 0)) + if (b2 & (1 << 0)) { pad.button |= PAD_BUTTON_START; - if (b2 & (1 << 1)) + } + if (b2 & (1 << 1)) { pad.button |= PAD_TRIGGER_Z; - if (b2 & (1 << 2)) + } + if (b2 & (1 << 2)) { pad.button |= PAD_TRIGGER_R; - if (b2 & (1 << 3)) + } + if (b2 & (1 << 3)) { pad.button |= PAD_TRIGGER_L; + } - if (get_origin) + if (get_origin) { pad.button |= PAD_GET_ORIGIN; + } pad.stickX = adapter_payload[1 + (9 * port) + 3]; pad.stickY = adapter_payload[1 + (9 * port) + 4]; @@ -86,7 +99,7 @@ GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) { } void PadToState(GCPadStatus pad, GCState& state) { - //std::lock_guard lock{s_mutex}; + // std::lock_guard lock{s_mutex}; state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A); state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B); state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X); @@ -125,7 +138,7 @@ static void Read() { std::begin(controller_payload_copy)); payload_size = payload_size_in; } - + GCPadStatus pad[4]; if (payload_size != sizeof(controller_payload_copy) || controller_payload_copy[0] != LIBUSB_DT_HID) { @@ -137,8 +150,9 @@ static void Read() { } for (int port = 0; port < 4; port++) { if (DeviceConnected(port) && configuring) { - if (pad[port].button != PAD_GET_ORIGIN) + if (pad[port].button != PAD_GET_ORIGIN) { pad_queue[port].Push(pad[port]); + } // Accounting for a threshold here because of some controller variance if (pad[port].stickX > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD || @@ -186,8 +200,9 @@ static void ScanThreadFunc() { void Init() { - if (usb_adapter_handle != nullptr) + if (usb_adapter_handle != nullptr) { return; + } LOG_INFO(Input, "GC Adapter Initialization started"); current_status = NO_ADAPTER_DETECTED; @@ -197,10 +212,12 @@ void Init() { } void StartScanThread() { - if (detect_thread_running) + if (detect_thread_running) { return; - if (!libusb_ctx) + } + if (!libusb_ctx) { return; + } detect_thread_running = true; detect_thread = std::thread(ScanThreadFunc); @@ -212,15 +229,17 @@ void StopScanThread() { static void Setup() { // Reset the error status in case the adapter gets unplugged - if (current_status < 0) + if (current_status < 0) { current_status = NO_ADAPTER_DETECTED; + } - for (int i = 0; i < 4; i++) + for (int i = 0; i < 4; i++) { adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; - + } + libusb_device** devs; // pointer to list of connected usb devices - int cnt = libusb_get_device_list(libusb_ctx, &devs); //get the list of devices + int cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices for (int i = 0; i < cnt; i++) { if (CheckDeviceAccess(devs[i])) { @@ -247,9 +266,8 @@ static bool CheckDeviceAccess(libusb_device* device) { ret = libusb_open(device, &usb_adapter_handle); if (ret == LIBUSB_ERROR_ACCESS) { - LOG_ERROR(Input, - "Yuzu can not gain access to this device: ID %04X:%04X.", - desc.idVendor, desc.idProduct); + LOG_ERROR(Input, "Yuzu can not gain access to this device: ID %04X:%04X.", desc.idVendor, + desc.idProduct); return false; } if (ret) { @@ -260,8 +278,9 @@ static bool CheckDeviceAccess(libusb_device* device) { ret = libusb_kernel_driver_active(usb_adapter_handle, 0); if (ret == 1) { ret = libusb_detach_kernel_driver(usb_adapter_handle, 0); - if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) + if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) { LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", ret); + } } if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) { @@ -290,8 +309,9 @@ static void GetGCEndpoint(libusb_device* device) { const libusb_interface_descriptor* interface = &interfaceContainer->altsetting[i]; for (u8 e = 0; e < interface->bNumEndpoints; e++) { const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e]; - if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) + if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) { input_endpoint = endpoint->bEndpointAddress; + } } } } @@ -311,16 +331,20 @@ void Shutdown() { static void Reset() { std::unique_lock lock(initialization_mutex, std::defer_lock); - if (!lock.try_lock()) + if (!lock.try_lock()) { return; - if (current_status != ADAPTER_DETECTED) + } + if (current_status != ADAPTER_DETECTED) { return; + } - if (adapter_thread_running) + if (adapter_thread_running) { adapter_input_thread.join(); + } - for (int i = 0; i < 4; i++) + for (int i = 0; i < 4; i++) { adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; + } current_status = NO_ADAPTER_DETECTED; -- cgit v1.2.3 From 121af3646dad0f80453d2ffffa688dd4435d3acc Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 18:43:01 -0400 Subject: Singleton GC Adapter class, remove globals, fix naming convention Fix clang formatting Manual fix for configure_input_player formatting Add missing lib usb cmake command --- src/input_common/gcadapter/gc_adapter.cpp | 176 +++++++++++++++--------------- 1 file changed, 87 insertions(+), 89 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index dc04116ce..0696a96c7 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -3,45 +3,41 @@ // Refer to the license.txt file included. #include "common/logging/log.h" -#include "common/threadsafe_queue.h" #include "input_common/gcadapter/gc_adapter.h" -Common::SPSCQueue pad_queue[4]; -struct GCState state[4]; - namespace GCAdapter { +Adapter* Adapter::adapter_instance{nullptr}; -static libusb_device_handle* usb_adapter_handle = nullptr; -static u8 adapter_controllers_status[4] = { - ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE, - ControllerTypes::CONTROLLER_NONE, ControllerTypes::CONTROLLER_NONE}; - -static std::mutex s_mutex; - -static std::thread adapter_input_thread; -static bool adapter_thread_running; - -static std::mutex initialization_mutex; -static std::thread detect_thread; -static bool detect_thread_running = false; +Adapter::Adapter() { + if (usb_adapter_handle != nullptr) { + return; + } + LOG_INFO(Input, "GC Adapter Initialization started"); -static libusb_context* libusb_ctx; + current_status = NO_ADAPTER_DETECTED; + libusb_init(&libusb_ctx); -static u8 input_endpoint = 0; + StartScanThread(); +} -static bool configuring = false; +Adapter* Adapter::GetInstance() { + if (!adapter_instance) { + adapter_instance = new Adapter; + } + return adapter_instance; +} -GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) { +GCPadStatus Adapter::CheckStatus(int port, u8 adapter_payload[37]) { GCPadStatus pad = {}; bool get_origin = false; - u8 type = adapter_payload[1 + (9 * port)] >> 4; - if (type) + ControllerTypes type = ControllerTypes(adapter_payload[1 + (9 * port)] >> 4); + if (type != ControllerTypes::None) get_origin = true; adapter_controllers_status[port] = type; - if (adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE) { + if (adapter_controllers_status[port] != ControllerTypes::None) { u8 b1 = adapter_payload[1 + (9 * port) + 1]; u8 b2 = adapter_payload[1 + (9 * port) + 2]; @@ -88,18 +84,17 @@ GCPadStatus CheckStatus(int port, u8 adapter_payload[37]) { pad.button |= PAD_GET_ORIGIN; } - pad.stickX = adapter_payload[1 + (9 * port) + 3]; - pad.stickY = adapter_payload[1 + (9 * port) + 4]; - pad.substickX = adapter_payload[1 + (9 * port) + 5]; - pad.substickY = adapter_payload[1 + (9 * port) + 6]; - pad.triggerLeft = adapter_payload[1 + (9 * port) + 7]; - pad.triggerRight = adapter_payload[1 + (9 * port) + 8]; + pad.stick_x = adapter_payload[1 + (9 * port) + 3]; + pad.stick_y = adapter_payload[1 + (9 * port) + 4]; + pad.substick_x = adapter_payload[1 + (9 * port) + 5]; + pad.substick_y = adapter_payload[1 + (9 * port) + 6]; + pad.trigger_left = adapter_payload[1 + (9 * port) + 7]; + pad.trigger_right = adapter_payload[1 + (9 * port) + 8]; } return pad; } -void PadToState(GCPadStatus pad, GCState& state) { - // std::lock_guard lock{s_mutex}; +void Adapter::PadToState(GCPadStatus pad, GCState& state) { state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A); state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B); state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X); @@ -112,15 +107,15 @@ void PadToState(GCPadStatus pad, GCState& state) { state.buttons.insert_or_assign(PAD_TRIGGER_Z, pad.button & PAD_TRIGGER_Z); state.buttons.insert_or_assign(PAD_TRIGGER_L, pad.button & PAD_TRIGGER_L); state.buttons.insert_or_assign(PAD_TRIGGER_R, pad.button & PAD_TRIGGER_R); - state.axes.insert_or_assign(STICK_X, pad.stickX); - state.axes.insert_or_assign(STICK_Y, pad.stickY); - state.axes.insert_or_assign(SUBSTICK_X, pad.substickX); - state.axes.insert_or_assign(SUBSTICK_Y, pad.substickY); - state.axes.insert_or_assign(TRIGGER_LEFT, pad.triggerLeft); - state.axes.insert_or_assign(TRIGGER_RIGHT, pad.triggerRight); + state.axes.insert_or_assign(static_cast(PadAxes::StickX), pad.stick_x); + state.axes.insert_or_assign(static_cast(PadAxes::StickY), pad.stick_y); + state.axes.insert_or_assign(static_cast(PadAxes::SubstickX), pad.substick_x); + state.axes.insert_or_assign(static_cast(PadAxes::SubstickY), pad.substick_y); + state.axes.insert_or_assign(static_cast(PadAxes::TriggerLeft), pad.trigger_left); + state.axes.insert_or_assign(static_cast(PadAxes::TriggerRight), pad.trigger_right); } -static void Read() { +void Adapter::Read() { LOG_INFO(Input, "GC Adapter Read() thread started"); int payload_size_in; @@ -145,8 +140,9 @@ static void Read() { LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, controller_payload_copy[0]); } else { - for (int i = 0; i < 4; i++) - pad[i] = CheckStatus(i, controller_payload_copy); + for (int port = 0; port < 4; port++) { + pad[port] = CheckStatus(port, controller_payload_copy); + } } for (int port = 0; port < 4; port++) { if (DeviceConnected(port) && configuring) { @@ -155,28 +151,36 @@ static void Read() { } // Accounting for a threshold here because of some controller variance - if (pad[port].stickX > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD || - pad[port].stickX < pad[port].MAIN_STICK_CENTER_X - pad[port].THRESHOLD) { - pad[port].axis_which = STICK_X; - pad[port].axis_value = pad[port].stickX; + if (pad[port].stick_x > + pad_constants.MAIN_STICK_CENTER_X + pad_constants.THRESHOLD || + pad[port].stick_x < + pad_constants.MAIN_STICK_CENTER_X - pad_constants.THRESHOLD) { + pad[port].axis = GCAdapter::PadAxes::StickX; + pad[port].axis_value = pad[port].stick_x; pad_queue[port].Push(pad[port]); } - if (pad[port].stickY > pad[port].MAIN_STICK_CENTER_Y + pad[port].THRESHOLD || - pad[port].stickY < pad[port].MAIN_STICK_CENTER_Y - pad[port].THRESHOLD) { - pad[port].axis_which = STICK_Y; - pad[port].axis_value = pad[port].stickY; + if (pad[port].stick_y > + pad_constants.MAIN_STICK_CENTER_Y + pad_constants.THRESHOLD || + pad[port].stick_y < + pad_constants.MAIN_STICK_CENTER_Y - pad_constants.THRESHOLD) { + pad[port].axis = GCAdapter::PadAxes::StickY; + pad[port].axis_value = pad[port].stick_y; pad_queue[port].Push(pad[port]); } - if (pad[port].substickX > pad[port].C_STICK_CENTER_X + pad[port].THRESHOLD || - pad[port].substickX < pad[port].C_STICK_CENTER_X - pad[port].THRESHOLD) { - pad[port].axis_which = SUBSTICK_X; - pad[port].axis_value = pad[port].substickX; + if (pad[port].substick_x > + pad_constants.C_STICK_CENTER_X + pad_constants.THRESHOLD || + pad[port].substick_x < + pad_constants.C_STICK_CENTER_X - pad_constants.THRESHOLD) { + pad[port].axis = GCAdapter::PadAxes::SubstickX; + pad[port].axis_value = pad[port].substick_x; pad_queue[port].Push(pad[port]); } - if (pad[port].substickY > pad[port].C_STICK_CENTER_Y + pad[port].THRESHOLD || - pad[port].substickY < pad[port].C_STICK_CENTER_Y - pad[port].THRESHOLD) { - pad[port].axis_which = SUBSTICK_Y; - pad[port].axis_value = pad[port].substickY; + if (pad[port].substick_y > + pad_constants.C_STICK_CENTER_Y + pad_constants.THRESHOLD || + pad[port].substick_y < + pad_constants.C_STICK_CENTER_Y - pad_constants.THRESHOLD) { + pad[port].axis = GCAdapter::PadAxes::SubstickY; + pad[port].axis_value = pad[port].substick_y; pad_queue[port].Push(pad[port]); } } @@ -186,7 +190,7 @@ static void Read() { } } -static void ScanThreadFunc() { +void Adapter::ScanThreadFunc() { LOG_INFO(Input, "GC Adapter scanning thread started"); while (detect_thread_running) { @@ -198,20 +202,7 @@ static void ScanThreadFunc() { } } -void Init() { - - if (usb_adapter_handle != nullptr) { - return; - } - LOG_INFO(Input, "GC Adapter Initialization started"); - - current_status = NO_ADAPTER_DETECTED; - libusb_init(&libusb_ctx); - - StartScanThread(); -} - -void StartScanThread() { +void Adapter::StartScanThread() { if (detect_thread_running) { return; } @@ -220,21 +211,21 @@ void StartScanThread() { } detect_thread_running = true; - detect_thread = std::thread(ScanThreadFunc); + detect_thread = std::thread([=] { ScanThreadFunc(); }); } -void StopScanThread() { +void Adapter::StopScanThread() { detect_thread.join(); } -static void Setup() { +void Adapter::Setup() { // Reset the error status in case the adapter gets unplugged if (current_status < 0) { current_status = NO_ADAPTER_DETECTED; } for (int i = 0; i < 4; i++) { - adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; + adapter_controllers_status[i] = ControllerTypes::None; } libusb_device** devs; // pointer to list of connected usb devices @@ -250,7 +241,7 @@ static void Setup() { } } -static bool CheckDeviceAccess(libusb_device* device) { +bool Adapter::CheckDeviceAccess(libusb_device* device) { libusb_device_descriptor desc; int ret = libusb_get_device_descriptor(device, &desc); if (ret) { @@ -300,7 +291,7 @@ static bool CheckDeviceAccess(libusb_device* device) { return true; } -static void GetGCEndpoint(libusb_device* device) { +void Adapter::GetGCEndpoint(libusb_device* device) { libusb_config_descriptor* config = nullptr; libusb_get_config_descriptor(device, 0, &config); for (u8 ic = 0; ic < config->bNumInterfaces; ic++) { @@ -318,18 +309,17 @@ static void GetGCEndpoint(libusb_device* device) { adapter_thread_running = true; current_status = ADAPTER_DETECTED; - - adapter_input_thread = std::thread(Read); // Read input + adapter_input_thread = std::thread([=] { Read(); }); // Read input } -void Shutdown() { +Adapter::~Adapter() { StopScanThread(); Reset(); current_status = NO_ADAPTER_DETECTED; } -static void Reset() { +void Adapter::Reset() { std::unique_lock lock(initialization_mutex, std::defer_lock); if (!lock.try_lock()) { return; @@ -343,7 +333,7 @@ static void Reset() { } for (int i = 0; i < 4; i++) { - adapter_controllers_status[i] = ControllerTypes::CONTROLLER_NONE; + adapter_controllers_status[i] = ControllerTypes::None; } current_status = NO_ADAPTER_DETECTED; @@ -355,20 +345,28 @@ static void Reset() { } } -bool DeviceConnected(int port) { - return adapter_controllers_status[port] != ControllerTypes::CONTROLLER_NONE; +bool Adapter::DeviceConnected(int port) { + return adapter_controllers_status[port] != ControllerTypes::None; } -void ResetDeviceType(int port) { - adapter_controllers_status[port] = ControllerTypes::CONTROLLER_NONE; +void Adapter::ResetDeviceType(int port) { + adapter_controllers_status[port] = ControllerTypes::None; } -void BeginConfiguration() { +void Adapter::BeginConfiguration() { configuring = true; } -void EndConfiguration() { +void Adapter::EndConfiguration() { configuring = false; } +std::array, 4>& Adapter::GetPadQueue() { + return pad_queue; +} + +std::array& Adapter::GetPadState() { + return state; +} + } // end of namespace GCAdapter -- cgit v1.2.3 From 968d631aa59a0a4e51e219eaa143d2b95593c3e7 Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 21:15:58 -0400 Subject: std::arrays where appropriate, clear q in adapter class, other touch ups --- src/input_common/gcadapter/gc_adapter.cpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 0696a96c7..498bd0d6e 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -134,7 +134,7 @@ void Adapter::Read() { payload_size = payload_size_in; } - GCPadStatus pad[4]; + std::array pad; if (payload_size != sizeof(controller_payload_copy) || controller_payload_copy[0] != LIBUSB_DT_HID) { LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, @@ -224,9 +224,7 @@ void Adapter::Setup() { current_status = NO_ADAPTER_DETECTED; } - for (int i = 0; i < 4; i++) { - adapter_controllers_status[i] = ControllerTypes::None; - } + adapter_controllers_status.fill(ControllerTypes::None); libusb_device** devs; // pointer to list of connected usb devices @@ -332,9 +330,7 @@ void Adapter::Reset() { adapter_input_thread.join(); } - for (int i = 0; i < 4; i++) { - adapter_controllers_status[i] = ControllerTypes::None; - } + adapter_controllers_status.fill(ControllerTypes::None); current_status = NO_ADAPTER_DETECTED; @@ -354,10 +350,16 @@ void Adapter::ResetDeviceType(int port) { } void Adapter::BeginConfiguration() { + for (auto& pq : pad_queue) { + pq.Clear(); + } configuring = true; } void Adapter::EndConfiguration() { + for (auto& pq : pad_queue) { + pq.Clear(); + } configuring = false; } -- cgit v1.2.3 From 46b4461fbb0514dd50c096ef896b1752d81079d0 Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 21:50:58 -0400 Subject: shared_ptr for the GC adapter class, constexpr constants --- src/input_common/gcadapter/gc_adapter.cpp | 40 +++++++++++++------------------ 1 file changed, 16 insertions(+), 24 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 498bd0d6e..db72d7633 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -6,7 +6,6 @@ #include "input_common/gcadapter/gc_adapter.h" namespace GCAdapter { -Adapter* Adapter::adapter_instance{nullptr}; Adapter::Adapter() { if (usb_adapter_handle != nullptr) { @@ -20,13 +19,6 @@ Adapter::Adapter() { StartScanThread(); } -Adapter* Adapter::GetInstance() { - if (!adapter_instance) { - adapter_instance = new Adapter; - } - return adapter_instance; -} - GCPadStatus Adapter::CheckStatus(int port, u8 adapter_payload[37]) { GCPadStatus pad = {}; bool get_origin = false; @@ -151,34 +143,26 @@ void Adapter::Read() { } // Accounting for a threshold here because of some controller variance - if (pad[port].stick_x > - pad_constants.MAIN_STICK_CENTER_X + pad_constants.THRESHOLD || - pad[port].stick_x < - pad_constants.MAIN_STICK_CENTER_X - pad_constants.THRESHOLD) { + if (pad[port].stick_x > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD || + pad[port].stick_x < pad[port].MAIN_STICK_CENTER_X - pad[port].THRESHOLD) { pad[port].axis = GCAdapter::PadAxes::StickX; pad[port].axis_value = pad[port].stick_x; pad_queue[port].Push(pad[port]); } - if (pad[port].stick_y > - pad_constants.MAIN_STICK_CENTER_Y + pad_constants.THRESHOLD || - pad[port].stick_y < - pad_constants.MAIN_STICK_CENTER_Y - pad_constants.THRESHOLD) { + if (pad[port].stick_y > pad[port].MAIN_STICK_CENTER_Y + pad[port].THRESHOLD || + pad[port].stick_y < pad[port].MAIN_STICK_CENTER_Y - pad[port].THRESHOLD) { pad[port].axis = GCAdapter::PadAxes::StickY; pad[port].axis_value = pad[port].stick_y; pad_queue[port].Push(pad[port]); } - if (pad[port].substick_x > - pad_constants.C_STICK_CENTER_X + pad_constants.THRESHOLD || - pad[port].substick_x < - pad_constants.C_STICK_CENTER_X - pad_constants.THRESHOLD) { + if (pad[port].substick_x > pad[port].C_STICK_CENTER_X + pad[port].THRESHOLD || + pad[port].substick_x < pad[port].C_STICK_CENTER_X - pad[port].THRESHOLD) { pad[port].axis = GCAdapter::PadAxes::SubstickX; pad[port].axis_value = pad[port].substick_x; pad_queue[port].Push(pad[port]); } - if (pad[port].substick_y > - pad_constants.C_STICK_CENTER_Y + pad_constants.THRESHOLD || - pad[port].substick_y < - pad_constants.C_STICK_CENTER_Y - pad_constants.THRESHOLD) { + if (pad[port].substick_y > pad[port].C_STICK_CENTER_Y + pad[port].THRESHOLD || + pad[port].substick_y < pad[port].C_STICK_CENTER_Y - pad[port].THRESHOLD) { pad[port].axis = GCAdapter::PadAxes::SubstickY; pad[port].axis_value = pad[port].substick_y; pad_queue[port].Push(pad[port]); @@ -367,8 +351,16 @@ std::array, 4>& Adapter::GetPadQueue() { return pad_queue; } +const std::array, 4>& Adapter::GetPadQueue() const { + return pad_queue; +} + std::array& Adapter::GetPadState() { return state; } +const std::array& Adapter::GetPadState() const { + return state; +} + } // end of namespace GCAdapter -- cgit v1.2.3 From 0f729ef0785eba2a2bd8e9581da4050209c2611d Mon Sep 17 00:00:00 2001 From: Ameer Date: Sun, 21 Jun 2020 22:58:53 -0400 Subject: fix for sleep using stl --- src/input_common/gcadapter/gc_adapter.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index db72d7633..e3bcb24f6 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -2,6 +2,8 @@ // Licensed under GPLv2+ // Refer to the license.txt file included. +#include +#include #include "common/logging/log.h" #include "input_common/gcadapter/gc_adapter.h" @@ -182,7 +184,7 @@ void Adapter::ScanThreadFunc() { std::lock_guard lk(initialization_mutex); Setup(); } - Sleep(500); + std::this_thread::sleep_for(std::chrono::milliseconds(500)); } } -- cgit v1.2.3 From fcc23139f622963c86e7f53c8b96f6f214294032 Mon Sep 17 00:00:00 2001 From: Ameer Date: Mon, 22 Jun 2020 18:11:59 -0400 Subject: std::array and const reference passing of non-trivial objects --- src/input_common/gcadapter/gc_adapter.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index e3bcb24f6..745f1be27 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -21,7 +21,7 @@ Adapter::Adapter() { StartScanThread(); } -GCPadStatus Adapter::CheckStatus(int port, u8 adapter_payload[37]) { +GCPadStatus Adapter::CheckStatus(int port, const std::array& adapter_payload) { GCPadStatus pad = {}; bool get_origin = false; @@ -88,7 +88,7 @@ GCPadStatus Adapter::CheckStatus(int port, u8 adapter_payload[37]) { return pad; } -void Adapter::PadToState(GCPadStatus pad, GCState& state) { +void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A); state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B); state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X); @@ -112,15 +112,15 @@ void Adapter::PadToState(GCPadStatus pad, GCState& state) { void Adapter::Read() { LOG_INFO(Input, "GC Adapter Read() thread started"); - int payload_size_in; - u8 adapter_payload[37]; + int payload_size_in, payload_size; + std::array adapter_payload; + std::array controller_payload_copy; + std::array pad; + while (adapter_thread_running) { - libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload, + libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(), sizeof(adapter_payload), &payload_size_in, 32); - - int payload_size = 0; - u8 controller_payload_copy[37]; - + payload_size = 0; { std::lock_guard lk(s_mutex); std::copy(std::begin(adapter_payload), std::end(adapter_payload), @@ -128,7 +128,6 @@ void Adapter::Read() { payload_size = payload_size_in; } - std::array pad; if (payload_size != sizeof(controller_payload_copy) || controller_payload_copy[0] != LIBUSB_DT_HID) { LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, @@ -365,4 +364,4 @@ const std::array& Adapter::GetPadState() const { return state; } -} // end of namespace GCAdapter +} // namespace GCAdapter -- cgit v1.2.3 From d4e07fd95e999e34562428c628985a6eb1fb532d Mon Sep 17 00:00:00 2001 From: Ameer Date: Tue, 23 Jun 2020 12:47:58 -0400 Subject: Fix deallocation of GC Adapter --- src/input_common/gcadapter/gc_adapter.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 745f1be27..887cde263 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -130,6 +130,7 @@ void Adapter::Read() { if (payload_size != sizeof(controller_payload_copy) || controller_payload_copy[0] != LIBUSB_DT_HID) { + // TODO: It might be worthwhile to Shutdown GC Adapter if we encounter errors here LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, controller_payload_copy[0]); } else { @@ -200,6 +201,7 @@ void Adapter::StartScanThread() { } void Adapter::StopScanThread() { + detect_thread_running = false; detect_thread.join(); } @@ -298,8 +300,6 @@ void Adapter::GetGCEndpoint(libusb_device* device) { Adapter::~Adapter() { StopScanThread(); Reset(); - - current_status = NO_ADAPTER_DETECTED; } void Adapter::Reset() { @@ -312,11 +312,11 @@ void Adapter::Reset() { } if (adapter_thread_running) { + adapter_thread_running = false; adapter_input_thread.join(); } adapter_controllers_status.fill(ControllerTypes::None); - current_status = NO_ADAPTER_DETECTED; if (usb_adapter_handle) { @@ -324,6 +324,10 @@ void Adapter::Reset() { libusb_close(usb_adapter_handle); usb_adapter_handle = nullptr; } + + if (libusb_ctx) { + libusb_exit(libusb_ctx); + } } bool Adapter::DeviceConnected(int port) { -- cgit v1.2.3 From 743e1f02a06187164d55f4208b8e85742abd4498 Mon Sep 17 00:00:00 2001 From: Ameer Date: Tue, 23 Jun 2020 17:37:15 -0400 Subject: cleanup check access, read, and factory GetNextInput funcs. Use size rather than magic number --- src/input_common/gcadapter/gc_adapter.cpp | 169 ++++++++++++++---------------- 1 file changed, 76 insertions(+), 93 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 887cde263..9437d628f 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -21,57 +21,38 @@ Adapter::Adapter() { StartScanThread(); } -GCPadStatus Adapter::CheckStatus(int port, const std::array& adapter_payload) { +GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_payload) { GCPadStatus pad = {}; bool get_origin = false; ControllerTypes type = ControllerTypes(adapter_payload[1 + (9 * port)] >> 4); - if (type != ControllerTypes::None) + if (type != ControllerTypes::None) { get_origin = true; + } adapter_controllers_status[port] = type; - if (adapter_controllers_status[port] != ControllerTypes::None) { - u8 b1 = adapter_payload[1 + (9 * port) + 1]; - u8 b2 = adapter_payload[1 + (9 * port) + 2]; + constexpr std::array b1_buttons{ + PAD_BUTTON_A, PAD_BUTTON_B, PAD_BUTTON_X, PAD_BUTTON_Y, + PAD_BUTTON_LEFT, PAD_BUTTON_RIGHT, PAD_BUTTON_DOWN, PAD_BUTTON_UP}; - if (b1 & (1 << 0)) { - pad.button |= PAD_BUTTON_A; - } - if (b1 & (1 << 1)) { - pad.button |= PAD_BUTTON_B; - } - if (b1 & (1 << 2)) { - pad.button |= PAD_BUTTON_X; - } - if (b1 & (1 << 3)) { - pad.button |= PAD_BUTTON_Y; - } + constexpr std::array b2_buttons{PAD_BUTTON_START, PAD_TRIGGER_Z, PAD_TRIGGER_R, + PAD_TRIGGER_L}; - if (b1 & (1 << 4)) { - pad.button |= PAD_BUTTON_LEFT; - } - if (b1 & (1 << 5)) { - pad.button |= PAD_BUTTON_RIGHT; - } - if (b1 & (1 << 6)) { - pad.button |= PAD_BUTTON_DOWN; - } - if (b1 & (1 << 7)) { - pad.button |= PAD_BUTTON_UP; - } + if (adapter_controllers_status[port] != ControllerTypes::None) { + const u8 b1 = adapter_payload[1 + (9 * port) + 1]; + const u8 b2 = adapter_payload[1 + (9 * port) + 2]; - if (b2 & (1 << 0)) { - pad.button |= PAD_BUTTON_START; - } - if (b2 & (1 << 1)) { - pad.button |= PAD_TRIGGER_Z; - } - if (b2 & (1 << 2)) { - pad.button |= PAD_TRIGGER_R; + for (int i = 0; i < b1_buttons.size(); i++) { + if (b1 & (1 << i)) { + pad.button |= b1_buttons[i]; + } } - if (b2 & (1 << 3)) { - pad.button |= PAD_TRIGGER_L; + + for (int j = 0; j < b2_buttons.size(); j++) { + if (b2 & (1 << j)) { + pad.button |= b2_buttons[j]; + } } if (get_origin) { @@ -112,65 +93,65 @@ void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { void Adapter::Read() { LOG_INFO(Input, "GC Adapter Read() thread started"); - int payload_size_in, payload_size; + int payload_size_in, payload_size_copy; std::array adapter_payload; - std::array controller_payload_copy; - std::array pad; + std::array adapter_payload_copy; + std::array pads; while (adapter_thread_running) { libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(), sizeof(adapter_payload), &payload_size_in, 32); - payload_size = 0; + payload_size_copy = 0; { std::lock_guard lk(s_mutex); std::copy(std::begin(adapter_payload), std::end(adapter_payload), - std::begin(controller_payload_copy)); - payload_size = payload_size_in; + std::begin(adapter_payload_copy)); + payload_size_copy = payload_size_in; } - if (payload_size != sizeof(controller_payload_copy) || - controller_payload_copy[0] != LIBUSB_DT_HID) { + if (payload_size_copy != sizeof(adapter_payload_copy) || + adapter_payload_copy[0] != LIBUSB_DT_HID) { // TODO: It might be worthwhile to Shutdown GC Adapter if we encounter errors here - LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size, - controller_payload_copy[0]); + LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size_copy, + adapter_payload_copy[0]); } else { - for (int port = 0; port < 4; port++) { - pad[port] = CheckStatus(port, controller_payload_copy); + for (int port = 0; port < pads.size(); port++) { + pads[port] = GetPadStatus(port, adapter_payload_copy); } } - for (int port = 0; port < 4; port++) { + for (int port = 0; port < pads.size(); port++) { if (DeviceConnected(port) && configuring) { - if (pad[port].button != PAD_GET_ORIGIN) { - pad_queue[port].Push(pad[port]); + if (pads[port].button != PAD_GET_ORIGIN) { + pad_queue[port].Push(pads[port]); } // Accounting for a threshold here because of some controller variance - if (pad[port].stick_x > pad[port].MAIN_STICK_CENTER_X + pad[port].THRESHOLD || - pad[port].stick_x < pad[port].MAIN_STICK_CENTER_X - pad[port].THRESHOLD) { - pad[port].axis = GCAdapter::PadAxes::StickX; - pad[port].axis_value = pad[port].stick_x; - pad_queue[port].Push(pad[port]); + if (pads[port].stick_x > pads[port].MAIN_STICK_CENTER_X + pads[port].THRESHOLD || + pads[port].stick_x < pads[port].MAIN_STICK_CENTER_X - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::StickX; + pads[port].axis_value = pads[port].stick_x; + pad_queue[port].Push(pads[port]); } - if (pad[port].stick_y > pad[port].MAIN_STICK_CENTER_Y + pad[port].THRESHOLD || - pad[port].stick_y < pad[port].MAIN_STICK_CENTER_Y - pad[port].THRESHOLD) { - pad[port].axis = GCAdapter::PadAxes::StickY; - pad[port].axis_value = pad[port].stick_y; - pad_queue[port].Push(pad[port]); + if (pads[port].stick_y > pads[port].MAIN_STICK_CENTER_Y + pads[port].THRESHOLD || + pads[port].stick_y < pads[port].MAIN_STICK_CENTER_Y - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::StickY; + pads[port].axis_value = pads[port].stick_y; + pad_queue[port].Push(pads[port]); } - if (pad[port].substick_x > pad[port].C_STICK_CENTER_X + pad[port].THRESHOLD || - pad[port].substick_x < pad[port].C_STICK_CENTER_X - pad[port].THRESHOLD) { - pad[port].axis = GCAdapter::PadAxes::SubstickX; - pad[port].axis_value = pad[port].substick_x; - pad_queue[port].Push(pad[port]); + if (pads[port].substick_x > pads[port].C_STICK_CENTER_X + pads[port].THRESHOLD || + pads[port].substick_x < pads[port].C_STICK_CENTER_X - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::SubstickX; + pads[port].axis_value = pads[port].substick_x; + pad_queue[port].Push(pads[port]); } - if (pad[port].substick_y > pad[port].C_STICK_CENTER_Y + pad[port].THRESHOLD || - pad[port].substick_y < pad[port].C_STICK_CENTER_Y - pad[port].THRESHOLD) { - pad[port].axis = GCAdapter::PadAxes::SubstickY; - pad[port].axis_value = pad[port].substick_y; - pad_queue[port].Push(pad[port]); + if (pads[port].substick_y > pads[port].C_STICK_CENTER_Y + pads[port].THRESHOLD || + pads[port].substick_y < pads[port].C_STICK_CENTER_Y - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::SubstickY; + pads[port].axis_value = pads[port].substick_y; + pad_queue[port].Push(pads[port]); } } - PadToState(pad[port], state[port]); + PadToState(pads[port], state[port]); } std::this_thread::yield(); } @@ -215,11 +196,11 @@ void Adapter::Setup() { libusb_device** devs; // pointer to list of connected usb devices - int cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices + const int cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices for (int i = 0; i < cnt; i++) { if (CheckDeviceAccess(devs[i])) { - // GC Adapter found, registering it + // GC Adapter found and accessible, registering it GetGCEndpoint(devs[i]); break; } @@ -228,10 +209,11 @@ void Adapter::Setup() { bool Adapter::CheckDeviceAccess(libusb_device* device) { libusb_device_descriptor desc; - int ret = libusb_get_device_descriptor(device, &desc); - if (ret) { + const int get_descriptor_error = libusb_get_device_descriptor(device, &desc); + if (get_descriptor_error) { // could not acquire the descriptor, no point in trying to use it. - LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: %d", ret); + LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: %d", + get_descriptor_error); return false; } @@ -239,35 +221,36 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { // This isn’t the device we are looking for. return false; } - ret = libusb_open(device, &usb_adapter_handle); + const int open_error = libusb_open(device, &usb_adapter_handle); - if (ret == LIBUSB_ERROR_ACCESS) { + if (open_error == LIBUSB_ERROR_ACCESS) { LOG_ERROR(Input, "Yuzu can not gain access to this device: ID %04X:%04X.", desc.idVendor, desc.idProduct); return false; } - if (ret) { - LOG_ERROR(Input, "libusb_open failed to open device with error = %d", ret); + if (open_error) { + LOG_ERROR(Input, "libusb_open failed to open device with error = %d", open_error); return false; } - ret = libusb_kernel_driver_active(usb_adapter_handle, 0); - if (ret == 1) { - ret = libusb_detach_kernel_driver(usb_adapter_handle, 0); - if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) { - LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", ret); + int kernel_driver_error = libusb_kernel_driver_active(usb_adapter_handle, 0); + if (kernel_driver_error == 1) { + kernel_driver_error = libusb_detach_kernel_driver(usb_adapter_handle, 0); + if (kernel_driver_error != 0 && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) { + LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", + kernel_driver_error); } } - if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED) { + if (kernel_driver_error && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) { libusb_close(usb_adapter_handle); usb_adapter_handle = nullptr; return false; } - ret = libusb_claim_interface(usb_adapter_handle, 0); - if (ret) { - LOG_ERROR(Input, "libusb_claim_interface failed with error = %d", ret); + const int interface_claim_error = libusb_claim_interface(usb_adapter_handle, 0); + if (interface_claim_error) { + LOG_ERROR(Input, "libusb_claim_interface failed with error = %d", interface_claim_error); libusb_close(usb_adapter_handle); usb_adapter_handle = nullptr; return false; -- cgit v1.2.3 From c18dc9c707235d7ba6fe230cb3045f2c13d04e62 Mon Sep 17 00:00:00 2001 From: Ameer Date: Wed, 24 Jun 2020 11:39:30 -0400 Subject: padbutton enum class and struct initiailization --- src/input_common/gcadapter/gc_adapter.cpp | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 9437d628f..bba9bcc69 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -33,11 +33,13 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa adapter_controllers_status[port] = type; constexpr std::array b1_buttons{ - PAD_BUTTON_A, PAD_BUTTON_B, PAD_BUTTON_X, PAD_BUTTON_Y, - PAD_BUTTON_LEFT, PAD_BUTTON_RIGHT, PAD_BUTTON_DOWN, PAD_BUTTON_UP}; + PadButton::PAD_BUTTON_A, PadButton::PAD_BUTTON_B, PadButton::PAD_BUTTON_X, + PadButton::PAD_BUTTON_Y, PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, + PadButton::PAD_BUTTON_DOWN, PadButton::PAD_BUTTON_UP}; - constexpr std::array b2_buttons{PAD_BUTTON_START, PAD_TRIGGER_Z, PAD_TRIGGER_R, - PAD_TRIGGER_L}; + constexpr std::array b2_buttons{ + PadButton::PAD_BUTTON_START, PadButton::PAD_TRIGGER_Z, PadButton::PAD_TRIGGER_R, + PadButton::PAD_TRIGGER_L}; if (adapter_controllers_status[port] != ControllerTypes::None) { const u8 b1 = adapter_payload[1 + (9 * port) + 1]; @@ -45,13 +47,13 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa for (int i = 0; i < b1_buttons.size(); i++) { if (b1 & (1 << i)) { - pad.button |= b1_buttons[i]; + pad.button |= static_cast(b1_buttons[i]); } } for (int j = 0; j < b2_buttons.size(); j++) { if (b2 & (1 << j)) { - pad.button |= b2_buttons[j]; + pad.button |= static_cast(b2_buttons[j]); } } @@ -70,18 +72,11 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa } void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { - state.buttons.insert_or_assign(PAD_BUTTON_A, pad.button & PAD_BUTTON_A); - state.buttons.insert_or_assign(PAD_BUTTON_B, pad.button & PAD_BUTTON_B); - state.buttons.insert_or_assign(PAD_BUTTON_X, pad.button & PAD_BUTTON_X); - state.buttons.insert_or_assign(PAD_BUTTON_Y, pad.button & PAD_BUTTON_Y); - state.buttons.insert_or_assign(PAD_BUTTON_LEFT, pad.button & PAD_BUTTON_LEFT); - state.buttons.insert_or_assign(PAD_BUTTON_RIGHT, pad.button & PAD_BUTTON_RIGHT); - state.buttons.insert_or_assign(PAD_BUTTON_DOWN, pad.button & PAD_BUTTON_DOWN); - state.buttons.insert_or_assign(PAD_BUTTON_UP, pad.button & PAD_BUTTON_UP); - state.buttons.insert_or_assign(PAD_BUTTON_START, pad.button & PAD_BUTTON_START); - state.buttons.insert_or_assign(PAD_TRIGGER_Z, pad.button & PAD_TRIGGER_Z); - state.buttons.insert_or_assign(PAD_TRIGGER_L, pad.button & PAD_TRIGGER_L); - state.buttons.insert_or_assign(PAD_TRIGGER_R, pad.button & PAD_TRIGGER_R); + for (auto button : PadButtonArray) { + u16 button_value = static_cast(button); + state.buttons.insert_or_assign(button_value, pad.button & button_value); + } + state.axes.insert_or_assign(static_cast(PadAxes::StickX), pad.stick_x); state.axes.insert_or_assign(static_cast(PadAxes::StickY), pad.stick_y); state.axes.insert_or_assign(static_cast(PadAxes::SubstickX), pad.substick_x); -- cgit v1.2.3 From 3f739514e3fa5f3e5c64fa8172c796bd686f6e7d Mon Sep 17 00:00:00 2001 From: Ameer Date: Thu, 25 Jun 2020 19:31:51 -0400 Subject: Stop reading loop if error is encountered --- src/input_common/gcadapter/gc_adapter.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index bba9bcc69..173b5c325 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -95,7 +95,7 @@ void Adapter::Read() { while (adapter_thread_running) { libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(), - sizeof(adapter_payload), &payload_size_in, 32); + sizeof(adapter_payload), &payload_size_in, 16); payload_size_copy = 0; { std::lock_guard lk(s_mutex); @@ -106,9 +106,9 @@ void Adapter::Read() { if (payload_size_copy != sizeof(adapter_payload_copy) || adapter_payload_copy[0] != LIBUSB_DT_HID) { - // TODO: It might be worthwhile to Shutdown GC Adapter if we encounter errors here LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size_copy, adapter_payload_copy[0]); + adapter_thread_running = false; // error reading from adapter, stop reading. } else { for (int port = 0; port < pads.size(); port++) { pads[port] = GetPadStatus(port, adapter_payload_copy); @@ -291,14 +291,14 @@ void Adapter::Reset() { if (adapter_thread_running) { adapter_thread_running = false; - adapter_input_thread.join(); } + adapter_input_thread.join(); adapter_controllers_status.fill(ControllerTypes::None); current_status = NO_ADAPTER_DETECTED; if (usb_adapter_handle) { - libusb_release_interface(usb_adapter_handle, 0); + libusb_release_interface(usb_adapter_handle, 1); libusb_close(usb_adapter_handle); usb_adapter_handle = nullptr; } -- cgit v1.2.3 From ecbc8137117d6d37b231fc2745b281b6e7077e16 Mon Sep 17 00:00:00 2001 From: Ameer J <52414509+ameerj@users.noreply.github.com> Date: Thu, 25 Jun 2020 19:46:50 -0400 Subject: const& to button in button array Co-authored-by: VolcaEM <63682805+VolcaEM@users.noreply.github.com> --- src/input_common/gcadapter/gc_adapter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 173b5c325..80355a40d 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -72,7 +72,7 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa } void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { - for (auto button : PadButtonArray) { + for (auto const& button : PadButtonArray) { u16 button_value = static_cast(button); state.buttons.insert_or_assign(button_value, pad.button & button_value); } @@ -213,7 +213,7 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { } if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) { - // This isn’t the device we are looking for. + // This isnÂ’t the device we are looking for. return false; } const int open_error = libusb_open(device, &usb_adapter_handle); -- cgit v1.2.3 From bd697bef039ddf307ed7ddf3d9daf0fd7ec1ee8f Mon Sep 17 00:00:00 2001 From: Ameer J <52414509+ameerj@users.noreply.github.com> Date: Fri, 26 Jun 2020 23:46:49 -0400 Subject: left const auto&, comment punctuation. Co-authored-by: Morph <39850852+Morph1984@users.noreply.github.com> --- src/input_common/gcadapter/gc_adapter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 80355a40d..774246bdf 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -72,7 +72,7 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa } void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { - for (auto const& button : PadButtonArray) { + for (const auto& button : PadButtonArray) { u16 button_value = static_cast(button); state.buttons.insert_or_assign(button_value, pad.button & button_value); } @@ -213,7 +213,7 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { } if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) { - // This isnÂ’t the device we are looking for. + // This isn't the device we are looking for. return false; } const int open_error = libusb_open(device, &usb_adapter_handle); -- cgit v1.2.3 From dfdf87d844de6226fd043bb840de8525d8fbc0d1 Mon Sep 17 00:00:00 2001 From: Ameer Date: Tue, 30 Jun 2020 11:44:55 -0400 Subject: fix implicit conversion of size_t type to int --- src/input_common/gcadapter/gc_adapter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 774246bdf..b509b3e46 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -191,7 +191,7 @@ void Adapter::Setup() { libusb_device** devs; // pointer to list of connected usb devices - const int cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices + const std::size_t cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices for (int i = 0; i < cnt; i++) { if (CheckDeviceAccess(devs[i])) { -- cgit v1.2.3 From a76e11e7f0c97222388bede03325aa71f1434510 Mon Sep 17 00:00:00 2001 From: Ameer Date: Tue, 30 Jun 2020 17:28:02 -0400 Subject: Address feedback regarding increments, const vars, and general cleanup --- src/input_common/gcadapter/gc_adapter.cpp | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index b509b3e46..b98b85441 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -45,13 +45,13 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa const u8 b1 = adapter_payload[1 + (9 * port) + 1]; const u8 b2 = adapter_payload[1 + (9 * port) + 2]; - for (int i = 0; i < b1_buttons.size(); i++) { + for (std::size_t i = 0; i < b1_buttons.size(); ++i) { if (b1 & (1 << i)) { pad.button |= static_cast(b1_buttons[i]); } } - for (int j = 0; j < b2_buttons.size(); j++) { + for (std::size_t j = 0; j < b2_buttons.size(); ++j) { if (b2 & (1 << j)) { pad.button |= static_cast(b2_buttons[j]); } @@ -73,7 +73,7 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { for (const auto& button : PadButtonArray) { - u16 button_value = static_cast(button); + const u16 button_value = static_cast(button); state.buttons.insert_or_assign(button_value, pad.button & button_value); } @@ -86,7 +86,7 @@ void Adapter::PadToState(const GCPadStatus& pad, GCState& state) { } void Adapter::Read() { - LOG_INFO(Input, "GC Adapter Read() thread started"); + LOG_DEBUG(Input, "GC Adapter Read() thread started"); int payload_size_in, payload_size_copy; std::array adapter_payload; @@ -109,12 +109,10 @@ void Adapter::Read() { LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size_copy, adapter_payload_copy[0]); adapter_thread_running = false; // error reading from adapter, stop reading. - } else { - for (int port = 0; port < pads.size(); port++) { - pads[port] = GetPadStatus(port, adapter_payload_copy); - } + break; } - for (int port = 0; port < pads.size(); port++) { + for (std::size_t port = 0; port < pads.size(); ++port) { + pads[port] = GetPadStatus(port, adapter_payload_copy); if (DeviceConnected(port) && configuring) { if (pads[port].button != PAD_GET_ORIGIN) { pad_queue[port].Push(pads[port]); @@ -189,14 +187,16 @@ void Adapter::Setup() { adapter_controllers_status.fill(ControllerTypes::None); - libusb_device** devs; // pointer to list of connected usb devices + // pointer to list of connected usb devices + libusb_device** devices; - const std::size_t cnt = libusb_get_device_list(libusb_ctx, &devs); // get the list of devices + // populate the list of devices, get the count + const std::size_t device_count = libusb_get_device_list(libusb_ctx, &devices); - for (int i = 0; i < cnt; i++) { - if (CheckDeviceAccess(devs[i])) { + for (std::size_t index = 0; index < device_count; ++index) { + if (CheckDeviceAccess(devices[index])) { // GC Adapter found and accessible, registering it - GetGCEndpoint(devs[i]); + GetGCEndpoint(devices[index]); break; } } -- cgit v1.2.3 From 34a590e50966341cec5f1874410931decbce284f Mon Sep 17 00:00:00 2001 From: Ameer Date: Wed, 1 Jul 2020 12:52:50 -0400 Subject: Reset adapter state on init, fixes errors relating driver hang from unexpected unplug --- src/input_common/gcadapter/gc_adapter.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index b98b85441..1ddb9cdb4 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -97,6 +97,7 @@ void Adapter::Read() { libusb_interrupt_transfer(usb_adapter_handle, input_endpoint, adapter_payload.data(), sizeof(adapter_payload), &payload_size_in, 16); payload_size_copy = 0; + // this mutex might be redundant? { std::lock_guard lk(s_mutex); std::copy(std::begin(adapter_payload), std::end(adapter_payload), @@ -265,10 +266,17 @@ void Adapter::GetGCEndpoint(libusb_device* device) { const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e]; if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) { input_endpoint = endpoint->bEndpointAddress; + } else { + output_endpoint = endpoint->bEndpointAddress; } } } } + // This transfer seems to be responsible for clearing the state of the adapter + // Used to clear the "busy" state of when the device is unexpectedly unplugged + unsigned char clear_payload = 0x13; + libusb_interrupt_transfer(usb_adapter_handle, output_endpoint, &clear_payload, + sizeof(clear_payload), nullptr, 16); adapter_thread_running = true; current_status = ADAPTER_DETECTED; -- cgit v1.2.3 From 6b7c8e469b2d7943cd7771648659bc362e5d1ddd Mon Sep 17 00:00:00 2001 From: Ameer Date: Thu, 2 Jul 2020 15:54:44 -0400 Subject: Add LR triggers as axes, half press to initiate a press, add GC axis id in config, clarify some code blocks for better readability --- src/input_common/gcadapter/gc_adapter.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 1ddb9cdb4..82f97572f 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -144,6 +144,18 @@ void Adapter::Read() { pads[port].axis_value = pads[port].substick_y; pad_queue[port].Push(pads[port]); } + if (pads[port].trigger_left > pads[port].TRIGGER_CENTER + pads[port].THRESHOLD || + pads[port].trigger_left < pads[port].TRIGGER_CENTER - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::TriggerLeft; + pads[port].axis_value = pads[port].trigger_left; + pad_queue[port].Push(pads[port]); + } + if (pads[port].trigger_right > pads[port].TRIGGER_CENTER + pads[port].THRESHOLD || + pads[port].trigger_right < pads[port].TRIGGER_CENTER - pads[port].THRESHOLD) { + pads[port].axis = GCAdapter::PadAxes::TriggerRight; + pads[port].axis_value = pads[port].trigger_right; + pad_queue[port].Push(pads[port]); + } } PadToState(pads[port], state[port]); } -- cgit v1.2.3 From e69d715e3d42aaa5e99ebe8e578e64242d049a8c Mon Sep 17 00:00:00 2001 From: Ameer Date: Fri, 3 Jul 2020 11:52:07 -0400 Subject: Address lioncash feedback: Log formatting, extern const PadButtonArray, little touch ups --- src/input_common/gcadapter/gc_adapter.cpp | 40 ++++++++++++++++++++----------- 1 file changed, 26 insertions(+), 14 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index 82f97572f..f58b0e11c 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -9,6 +9,14 @@ namespace GCAdapter { +/// Used to loop through and assign button in poller +constexpr std::array PadButtonArray{ + PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, PadButton::PAD_BUTTON_DOWN, + PadButton::PAD_BUTTON_UP, PadButton::PAD_TRIGGER_Z, PadButton::PAD_TRIGGER_R, + PadButton::PAD_TRIGGER_L, PadButton::PAD_BUTTON_A, PadButton::PAD_BUTTON_B, + PadButton::PAD_BUTTON_X, PadButton::PAD_BUTTON_Y, PadButton::PAD_BUTTON_START, +}; + Adapter::Adapter() { if (usb_adapter_handle != nullptr) { return; @@ -32,27 +40,31 @@ GCPadStatus Adapter::GetPadStatus(int port, const std::array& adapter_pa adapter_controllers_status[port] = type; - constexpr std::array b1_buttons{ + static constexpr std::array b1_buttons{ PadButton::PAD_BUTTON_A, PadButton::PAD_BUTTON_B, PadButton::PAD_BUTTON_X, PadButton::PAD_BUTTON_Y, PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, - PadButton::PAD_BUTTON_DOWN, PadButton::PAD_BUTTON_UP}; + PadButton::PAD_BUTTON_DOWN, PadButton::PAD_BUTTON_UP, + }; - constexpr std::array b2_buttons{ - PadButton::PAD_BUTTON_START, PadButton::PAD_TRIGGER_Z, PadButton::PAD_TRIGGER_R, - PadButton::PAD_TRIGGER_L}; + static constexpr std::array b2_buttons{ + PadButton::PAD_BUTTON_START, + PadButton::PAD_TRIGGER_Z, + PadButton::PAD_TRIGGER_R, + PadButton::PAD_TRIGGER_L, + }; if (adapter_controllers_status[port] != ControllerTypes::None) { const u8 b1 = adapter_payload[1 + (9 * port) + 1]; const u8 b2 = adapter_payload[1 + (9 * port) + 2]; for (std::size_t i = 0; i < b1_buttons.size(); ++i) { - if (b1 & (1 << i)) { + if ((b1 & (1U << i)) != 0) { pad.button |= static_cast(b1_buttons[i]); } } for (std::size_t j = 0; j < b2_buttons.size(); ++j) { - if (b2 & (1 << j)) { + if ((b2 & (1U << j)) != 0) { pad.button |= static_cast(b2_buttons[j]); } } @@ -107,7 +119,7 @@ void Adapter::Read() { if (payload_size_copy != sizeof(adapter_payload_copy) || adapter_payload_copy[0] != LIBUSB_DT_HID) { - LOG_ERROR(Input, "error reading payload (size: %d, type: %02x)", payload_size_copy, + LOG_ERROR(Input, "error reading payload (size: {}, type: {:02x})", payload_size_copy, adapter_payload_copy[0]); adapter_thread_running = false; // error reading from adapter, stop reading. break; @@ -220,7 +232,7 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { const int get_descriptor_error = libusb_get_device_descriptor(device, &desc); if (get_descriptor_error) { // could not acquire the descriptor, no point in trying to use it. - LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: %d", + LOG_ERROR(Input, "libusb_get_device_descriptor failed with error: {}", get_descriptor_error); return false; } @@ -232,12 +244,12 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { const int open_error = libusb_open(device, &usb_adapter_handle); if (open_error == LIBUSB_ERROR_ACCESS) { - LOG_ERROR(Input, "Yuzu can not gain access to this device: ID %04X:%04X.", desc.idVendor, - desc.idProduct); + LOG_ERROR(Input, "Yuzu can not gain access to this device: ID {:04X}:{:04X}.", + desc.idVendor, desc.idProduct); return false; } if (open_error) { - LOG_ERROR(Input, "libusb_open failed to open device with error = %d", open_error); + LOG_ERROR(Input, "libusb_open failed to open device with error = {}", open_error); return false; } @@ -245,7 +257,7 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { if (kernel_driver_error == 1) { kernel_driver_error = libusb_detach_kernel_driver(usb_adapter_handle, 0); if (kernel_driver_error != 0 && kernel_driver_error != LIBUSB_ERROR_NOT_SUPPORTED) { - LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = %d", + LOG_ERROR(Input, "libusb_detach_kernel_driver failed with error = {}", kernel_driver_error); } } @@ -258,7 +270,7 @@ bool Adapter::CheckDeviceAccess(libusb_device* device) { const int interface_claim_error = libusb_claim_interface(usb_adapter_handle, 0); if (interface_claim_error) { - LOG_ERROR(Input, "libusb_claim_interface failed with error = %d", interface_claim_error); + LOG_ERROR(Input, "libusb_claim_interface failed with error = {}", interface_claim_error); libusb_close(usb_adapter_handle); usb_adapter_handle = nullptr; return false; -- cgit v1.2.3 From d00972fce1fe5f2eb13c7e5d7e4e56036cb6bc91 Mon Sep 17 00:00:00 2001 From: Ameer Date: Sat, 4 Jul 2020 00:40:48 -0400 Subject: Fix for always firing triggers on some controllers, trigger threshold more universal --- src/input_common/gcadapter/gc_adapter.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'src/input_common/gcadapter/gc_adapter.cpp') diff --git a/src/input_common/gcadapter/gc_adapter.cpp b/src/input_common/gcadapter/gc_adapter.cpp index f58b0e11c..b39d2a3fb 100644 --- a/src/input_common/gcadapter/gc_adapter.cpp +++ b/src/input_common/gcadapter/gc_adapter.cpp @@ -156,14 +156,12 @@ void Adapter::Read() { pads[port].axis_value = pads[port].substick_y; pad_queue[port].Push(pads[port]); } - if (pads[port].trigger_left > pads[port].TRIGGER_CENTER + pads[port].THRESHOLD || - pads[port].trigger_left < pads[port].TRIGGER_CENTER - pads[port].THRESHOLD) { + if (pads[port].trigger_left > pads[port].TRIGGER_THRESHOLD) { pads[port].axis = GCAdapter::PadAxes::TriggerLeft; pads[port].axis_value = pads[port].trigger_left; pad_queue[port].Push(pads[port]); } - if (pads[port].trigger_right > pads[port].TRIGGER_CENTER + pads[port].THRESHOLD || - pads[port].trigger_right < pads[port].TRIGGER_CENTER - pads[port].THRESHOLD) { + if (pads[port].trigger_right > pads[port].TRIGGER_THRESHOLD) { pads[port].axis = GCAdapter::PadAxes::TriggerRight; pads[port].axis_value = pads[port].trigger_right; pad_queue[port].Push(pads[port]); -- cgit v1.2.3