mirror/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-04-01 01:20:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

GCAdapter: Merge Read logic

Browse Source
This commit is contained in:
Pokechu22 2022-04-21 12:03:58 -07:00
parent 9ec65baf46
commit cd9edeacda
1 changed files with 11 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Source/Core/InputCommon/GCAdapter.cpp
View File

@ -98,9 +98,7 @@ constexpr size_t CONTROLER_OUTPUT_INIT_PAYLOAD_SIZE = 1;
constexpr size_t CONTROLER_OUTPUT_RUMBLE_PAYLOAD_SIZE = 5; constexpr size_t CONTROLER_OUTPUT_RUMBLE_PAYLOAD_SIZE = 5;
static std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> s_controller_payload; static std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> s_controller_payload;
#if GCADAPTER_USE_LIBUSB_IMPLEMENTATION
static std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> s_controller_payload_swap; static std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> s_controller_payload_swap;
#endif
// Only access with s_mutex held! // Only access with s_mutex held!
static int s_controller_payload_size = {0}; static int s_controller_payload_size = {0};
@ -114,11 +112,10 @@ static std::thread s_write_adapter_thread;
static Common::Flag s_write_adapter_thread_running; static Common::Flag s_write_adapter_thread_running;
static Common::Event s_write_happened; static Common::Event s_write_happened;
static std::mutex s_read_mutex;
#if GCADAPTER_USE_LIBUSB_IMPLEMENTATION #if GCADAPTER_USE_LIBUSB_IMPLEMENTATION
static std::mutex s_mutex;
static std::mutex s_init_mutex; static std::mutex s_init_mutex;
#elif GCADAPTER_USE_ANDROID_IMPLEMENTATION #elif GCADAPTER_USE_ANDROID_IMPLEMENTATION
static std::mutex s_read_mutex;
static std::mutex s_write_mutex; static std::mutex s_write_mutex;
#endif #endif
@ -157,9 +154,7 @@ static void Read()
Common::SetCurrentThreadName("GCAdapter Read Thread"); Common::SetCurrentThreadName("GCAdapter Read Thread");
NOTICE_LOG_FMT(CONTROLLERINTERFACE, "GCAdapter read thread started"); NOTICE_LOG_FMT(CONTROLLERINTERFACE, "GCAdapter read thread started");
#if GCADAPTER_USE_LIBUSB_IMPLEMENTATION #if GCADAPTER_USE_ANDROID_IMPLEMENTATION
int payload_size = 0;
#elif GCADAPTER_USE_ANDROID_IMPLEMENTATION
bool first_read = true; bool first_read = true;
JNIEnv* env = IDCache::GetEnvForThread(); JNIEnv* env = IDCache::GetEnvForThread();
@ -193,27 +188,24 @@ static void Read()
while (s_read_adapter_thread_running.IsSet()) while (s_read_adapter_thread_running.IsSet())
{ {
#if GCADAPTER_USE_LIBUSB_IMPLEMENTATION #if GCADAPTER_USE_LIBUSB_IMPLEMENTATION
int payload_size = 0;
int err = libusb_interrupt_transfer(s_handle, s_endpoint_in, s_controller_payload_swap.data(), int err = libusb_interrupt_transfer(s_handle, s_endpoint_in, s_controller_payload_swap.data(),
CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE, &payload_size, 16); CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE, &payload_size, 16);
if (err) if (err)
ERROR_LOG_FMT(CONTROLLERINTERFACE, "adapter libusb read failed: err={}", ERROR_LOG_FMT(CONTROLLERINTERFACE, "adapter libusb read failed: err={}",
libusb_error_name(err)); libusb_error_name(err));
#elif GCADAPTER_USE_ANDROID_IMPLEMENTATION
int payload_size = env->CallStaticIntMethod(s_adapter_class, input_func);
jbyte* java_data = env->GetByteArrayElements(*java_controller_payload, nullptr);
std::copy(java_data, java_data + CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE,
s_controller_payload_swap.begin());
#endif
{ {
std::lock_guard<std::mutex> lk(s_mutex); std::lock_guard<std::mutex> lk(s_read_mutex);
std::swap(s_controller_payload_swap, s_controller_payload); std::swap(s_controller_payload_swap, s_controller_payload);
s_controller_payload_size = payload_size; s_controller_payload_size = payload_size;
} }
#elif GCADAPTER_USE_ANDROID_IMPLEMENTATION #if GCADAPTER_USE_ANDROID_IMPLEMENTATION
int read_size = env->CallStaticIntMethod(s_adapter_class, input_func);
jbyte* java_data = env->GetByteArrayElements(*java_controller_payload, nullptr);
{
std::lock_guard<std::mutex> lk(s_read_mutex);
std::copy(java_data, java_data + CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE,
s_controller_payload.begin());
s_controller_payload_size = read_size;
}
env->ReleaseByteArrayElements(*java_controller_payload, java_data, 0); env->ReleaseByteArrayElements(*java_controller_payload, java_data, 0);
if (first_read) if (first_read)
@ -683,11 +675,7 @@ GCPadStatus Input(int chan)
std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> controller_payload_copy{}; std::array<u8, CONTROLER_INPUT_PAYLOAD_EXPECTED_SIZE> controller_payload_copy{};
{ {
#if GCADAPTER_USE_LIBUSB_IMPLEMENTATION
std::lock_guard<std::mutex> lk(s_mutex);
#elif GCADAPTER_USE_ANDROID_IMPLEMENTATION
std::lock_guard<std::mutex> lk(s_read_mutex); std::lock_guard<std::mutex> lk(s_read_mutex);
#endif
controller_payload_copy = s_controller_payload; controller_payload_copy = s_controller_payload;
payload_size = s_controller_payload_size; payload_size = s_controller_payload_size;
} }