1 files changed, 174 insertions, 0 deletions

diff --git a/contrib/SDL-3.2.8/src/hidapi/libusb/hidapi_thread_pthread.h b/contrib/SDL-3.2.8/src/hidapi/libusb/hidapi_thread_pthread.h
new file mode 100644
index 0000000..0abe733
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/hidapi/libusb/hidapi_thread_pthread.h
@@ -0,0 +1,174 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ libusb/hidapi Team
+
+ Sam Lantinga
+
+ Copyright 2023, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        https://github.com/libusb/hidapi .
+********************************************************/
+
+#include <pthread.h>
+
+#if defined(__ANDROID__) && __ANDROID_API__ < __ANDROID_API_N__
+
+/* Barrier implementation because Android/Bionic don't have pthread_barrier.
+   This implementation came from Brent Priddy and was posted on
+   StackOverflow. It is used with his permission. */
+typedef int pthread_barrierattr_t;
+typedef struct pthread_barrier {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int count;
+    int trip_count;
+} pthread_barrier_t;
+
+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+{
+        if(count == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
+                return -1;
+        }
+        if(pthread_cond_init(&barrier->cond, 0) < 0) {
+                pthread_mutex_destroy(&barrier->mutex);
+                return -1;
+        }
+        barrier->trip_count = count;
+        barrier->count = 0;
+
+        return 0;
+}
+
+static int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+        pthread_cond_destroy(&barrier->cond);
+        pthread_mutex_destroy(&barrier->mutex);
+        return 0;
+}
+
+static int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+        pthread_mutex_lock(&barrier->mutex);
+        ++(barrier->count);
+        if(barrier->count >= barrier->trip_count) {
+                barrier->count = 0;
+                pthread_cond_broadcast(&barrier->cond);
+                pthread_mutex_unlock(&barrier->mutex);
+                return 1;
+        }
+        else {
+                pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+                pthread_mutex_unlock(&barrier->mutex);
+                return 0;
+        }
+}
+
+#endif
+
+#define HIDAPI_THREAD_TIMED_OUT ETIMEDOUT
+
+typedef struct timespec hidapi_timespec;
+
+typedef struct
+{
+        pthread_t thread;
+        pthread_mutex_t mutex; /* Protects input_reports */
+        pthread_cond_t condition;
+        pthread_barrier_t barrier; /* Ensures correct startup sequence */
+
+} hidapi_thread_state;
+
+static void hidapi_thread_state_init(hidapi_thread_state *state)
+{
+        pthread_mutex_init(&state->mutex, NULL);
+        pthread_cond_init(&state->condition, NULL);
+        pthread_barrier_init(&state->barrier, NULL, 2);
+}
+
+static void hidapi_thread_state_destroy(hidapi_thread_state *state)
+{
+        pthread_barrier_destroy(&state->barrier);
+        pthread_cond_destroy(&state->condition);
+        pthread_mutex_destroy(&state->mutex);
+}
+
+#define hidapi_thread_cleanup_push      pthread_cleanup_push
+#define hidapi_thread_cleanup_pop       pthread_cleanup_pop
+
+static void hidapi_thread_mutex_lock(hidapi_thread_state *state)
+{
+        pthread_mutex_lock(&state->mutex);
+}
+
+static void hidapi_thread_mutex_unlock(hidapi_thread_state *state)
+{
+        pthread_mutex_unlock(&state->mutex);
+}
+
+static void hidapi_thread_cond_wait(hidapi_thread_state *state)
+{
+        pthread_cond_wait(&state->condition, &state->mutex);
+}
+
+static int hidapi_thread_cond_timedwait(hidapi_thread_state *state, hidapi_timespec *ts)
+{
+        return pthread_cond_timedwait(&state->condition, &state->mutex, ts);
+}
+
+static void hidapi_thread_cond_signal(hidapi_thread_state *state)
+{
+        pthread_cond_signal(&state->condition);
+}
+
+static void hidapi_thread_cond_broadcast(hidapi_thread_state *state)
+{
+        pthread_cond_broadcast(&state->condition);
+}
+
+static void hidapi_thread_barrier_wait(hidapi_thread_state *state)
+{
+        pthread_barrier_wait(&state->barrier);
+}
+
+static void hidapi_thread_create(hidapi_thread_state *state, void *(*func)(void*), void *func_arg)
+{
+        pthread_create(&state->thread, NULL, func, func_arg);
+}
+
+static void hidapi_thread_join(hidapi_thread_state *state)
+{
+        pthread_join(state->thread, NULL);
+}
+
+static void hidapi_thread_gettime(hidapi_timespec *ts)
+{
+        clock_gettime(CLOCK_REALTIME, ts);
+}
+
+static void hidapi_thread_addtime(hidapi_timespec *ts, int milliseconds)
+{
+    ts->tv_sec += milliseconds / 1000;
+    ts->tv_nsec += (milliseconds % 1000) * 1000000;
+    if (ts->tv_nsec >= 1000000000L) {
+        ts->tv_sec++;
+        ts->tv_nsec -= 1000000000L;
+    }
+}