Updated with upstream suggestions in https://github.com/libusb/hidapi/pull/582

src/hidapi/libusb/hid.c

···
 	else if (milliseconds > 0) {
 		/* Non-blocking, but called with timeout. */
 		int res;
-		struct timespec ts;
+		hidapi_timespec ts;
 		hidapi_thread_gettime(&ts);
-		ts.tv_sec += milliseconds / 1000;
-		ts.tv_nsec += (milliseconds % 1000) * 1000000;
-		if (ts.tv_nsec >= 1000000000L) {
-			ts.tv_sec++;
-			ts.tv_nsec -= 1000000000L;
-		}
+		hidapi_thread_addtime(&ts, milliseconds);
 
 		while (!dev->input_reports && !dev->shutdown_thread) {
 			res = hidapi_thread_cond_timedwait(&dev->thread_state, &ts);

src/hidapi/libusb/hidapi_thread_pthread.h

···
 
  libusb/hidapi Team
 
- Copyright 2022, All Rights Reserved.
+ 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
···
 {
 	pthread_mutex_lock(&barrier->mutex);
 	++(barrier->count);
-	if(barrier->count >= barrier->trip_count)
-	{
+	if(barrier->count >= barrier->trip_count) {
 		barrier->count = 0;
 		pthread_cond_broadcast(&barrier->cond);
 		pthread_mutex_unlock(&barrier->mutex);
 		return 1;
 	}
-	else
-	{
+	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_cond_wait(&state->condition, &state->mutex);
 }
 
-static int hidapi_thread_cond_timedwait(hidapi_thread_state *state, struct timespec *ts)
+static int hidapi_thread_cond_timedwait(hidapi_thread_state *state, hidapi_timespec *ts)
 {
 	return pthread_cond_timedwait(&state->condition, &state->mutex, ts);
 }
···
 	pthread_join(state->thread, NULL);
 }
 
-static void hidapi_thread_gettime(struct timespec *ts)
+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;
+    }
+}

src/hidapi/libusb/hidapi_thread_sdl.h

···
 
 #define HIDAPI_THREAD_TIMED_OUT SDL_MUTEX_TIMEDOUT
 
+typedef Uint64 hidapi_timespec;
+
 typedef struct
 {
     SDL_Thread *thread;
···
     SDL_WaitCondition(state->condition, state->mutex);
 }
 
-static int hidapi_thread_cond_timedwait(hidapi_thread_state *state, struct timespec *ts)
+static int hidapi_thread_cond_timedwait(hidapi_thread_state *state, hidapi_timespec *ts)
 {
-    Uint64 end_time;
     Sint64 timeout_ns;
     Sint32 timeout_ms;
 
-    end_time = ts->tv_sec;
-    end_time *= 1000000000L;
-    end_time += ts->tv_nsec;
-    timeout_ns = (Sint64)(end_time - SDL_GetTicksNS());
+    timeout_ns = (Sint64)(*ts - SDL_GetTicksNS());
     if (timeout_ns <= 0) {
         timeout_ms = 0;
     } else {
···
     SDL_WaitThread(state->thread, NULL);
 }
 
-static void hidapi_thread_gettime(struct timespec *ts)
+static void hidapi_thread_gettime(hidapi_timespec *ts)
 {
-    Uint64 ns = SDL_GetTicksNS();
+    *ts = SDL_GetTicksNS();
+}
 
-    ts->tv_sec = ns / 1000000000L;
-    ts->tv_nsec = ns % 1000000000L;
+static void hidapi_thread_addtime(hidapi_timespec *ts, int milliseconds)
+{
+    *ts += SDL_MS_TO_NS(milliseconds);
 }