3 files changed, 384 insertions, 0 deletions

diff --git a/contrib/SDL-3.2.8/src/hidapi/hidtest/CMakeLists.txt b/contrib/SDL-3.2.8/src/hidapi/hidtest/CMakeLists.txt
new file mode 100644
index 0000000..19c50e1
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/hidapi/hidtest/CMakeLists.txt
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.1.3...3.25 FATAL_ERROR)
+project(hidtest C)
+
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    # hidtest is build as a standalone project
+
+    if(POLICY CMP0074)
+        # allow using hidapi_ROOT if CMake supports it
+        cmake_policy(SET CMP0074 NEW)
+    endif()
+
+    find_package(hidapi 0.12 REQUIRED)
+    message(STATUS "Using HIDAPI: ${hidapi_VERSION}")
+else()
+    # hidtest is built as part of the main HIDAPI build
+    message(STATUS "Building hidtest")
+endif()
+
+set(HIDAPI_HIDTEST_TARGETS)
+if(NOT WIN32 AND NOT APPLE AND CMAKE_SYSTEM_NAME MATCHES "Linux")
+    if(TARGET hidapi::hidraw)
+        add_executable(hidtest_hidraw test.c)
+        target_link_libraries(hidtest_hidraw hidapi::hidraw)
+        list(APPEND HIDAPI_HIDTEST_TARGETS hidtest_hidraw)
+    endif()
+    if(TARGET hidapi::libusb)
+        add_executable(hidtest_libusb test.c)
+        target_compile_definitions(hidtest_libusb PRIVATE USING_HIDAPI_LIBUSB)
+        target_link_libraries(hidtest_libusb hidapi::libusb)
+        list(APPEND HIDAPI_HIDTEST_TARGETS hidtest_libusb)
+    endif()
+else()
+    add_executable(hidtest test.c)
+    target_link_libraries(hidtest hidapi::hidapi)
+    list(APPEND HIDAPI_HIDTEST_TARGETS hidtest)
+endif()
+
+install(TARGETS ${HIDAPI_HIDTEST_TARGETS}
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+)
diff --git a/contrib/SDL-3.2.8/src/hidapi/hidtest/Makefile.am b/contrib/SDL-3.2.8/src/hidapi/hidtest/Makefile.am
new file mode 100644
index 0000000..b601307
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/hidapi/hidtest/Makefile.am
@@ -0,0 +1,28 @@
+AM_CPPFLAGS = -I$(top_srcdir)/hidapi/
+
+## Linux
+if OS_LINUX
+noinst_PROGRAMS = hidtest-libusb hidtest-hidraw
+
+hidtest_hidraw_SOURCES = test.c
+hidtest_hidraw_LDADD = $(top_builddir)/linux/libhidapi-hidraw.la
+
+hidtest_libusb_SOURCES = test.c
+hidtest_libusb_LDADD = $(top_builddir)/libusb/libhidapi-libusb.la
+else
+
+# Other OS's
+noinst_PROGRAMS = hidtest
+
+hidtest_SOURCES = test.c
+hidtest_LDADD = $(top_builddir)/$(backend)/libhidapi.la
+
+endif
+
+if OS_DARWIN
+AM_CPPFLAGS += -I$(top_srcdir)/mac/
+endif
+
+if OS_WINDOWS
+AM_CPPFLAGS += -I$(top_srcdir)/windows/
+endif
diff --git a/contrib/SDL-3.2.8/src/hidapi/hidtest/test.c b/contrib/SDL-3.2.8/src/hidapi/hidtest/test.c
new file mode 100644
index 0000000..1eb6582
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/hidapi/hidtest/test.c
@@ -0,0 +1,316 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ libusb/hidapi Team
+
+ Copyright 2022.
+
+ This contents of this file may be used by anyone
+ for any reason without any conditions and may be
+ used as a starting point for your own applications
+ which use HIDAPI.
+********************************************************/
+
+#include <stdio.h>
+#include <wchar.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <hidapi.h>
+
+// Headers needed for sleeping.
+#ifdef _WIN32
+        #include <windows.h>
+#else
+        #include <unistd.h>
+#endif
+
+// Fallback/example
+#ifndef HID_API_MAKE_VERSION
+#define HID_API_MAKE_VERSION(mj, mn, p) (((mj) << 24) | ((mn) << 8) | (p))
+#endif
+#ifndef HID_API_VERSION
+#define HID_API_VERSION HID_API_MAKE_VERSION(HID_API_VERSION_MAJOR, HID_API_VERSION_MINOR, HID_API_VERSION_PATCH)
+#endif
+
+//
+// Sample using platform-specific headers
+#if defined(__APPLE__) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0)
+#include <hidapi_darwin.h>
+#endif
+
+#if defined(_WIN32) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0)
+#include <hidapi_winapi.h>
+#endif
+
+#if defined(USING_HIDAPI_LIBUSB) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0)
+#include <hidapi_libusb.h>
+#endif
+//
+
+const char *hid_bus_name(hid_bus_type bus_type) {
+        static const char *const HidBusTypeName[] = {
+                "Unknown",
+                "USB",
+                "Bluetooth",
+                "I2C",
+                "SPI",
+        };
+
+        if ((int)bus_type < 0)
+                bus_type = HID_API_BUS_UNKNOWN;
+        if ((int)bus_type >= (int)(sizeof(HidBusTypeName) / sizeof(HidBusTypeName[0])))
+                bus_type = HID_API_BUS_UNKNOWN;
+
+        return HidBusTypeName[bus_type];
+}
+
+void print_device(struct hid_device_info *cur_dev) {
+        printf("Device Found\n  type: %04hx %04hx\n  path: %s\n  serial_number: %ls", cur_dev->vendor_id, cur_dev->product_id, cur_dev->path, cur_dev->serial_number);
+        printf("\n");
+        printf("  Manufacturer: %ls\n", cur_dev->manufacturer_string);
+        printf("  Product:      %ls\n", cur_dev->product_string);
+        printf("  Release:      %hx\n", cur_dev->release_number);
+        printf("  Interface:    %d\n",  cur_dev->interface_number);
+        printf("  Usage (page): 0x%hx (0x%hx)\n", cur_dev->usage, cur_dev->usage_page);
+        printf("  Bus type: %u (%s)\n", (unsigned)cur_dev->bus_type, hid_bus_name(cur_dev->bus_type));
+        printf("\n");
+}
+
+void print_hid_report_descriptor_from_device(hid_device *device) {
+        unsigned char descriptor[HID_API_MAX_REPORT_DESCRIPTOR_SIZE];
+        int res = 0;
+
+        printf("  Report Descriptor: ");
+        res = hid_get_report_descriptor(device, descriptor, sizeof(descriptor));
+        if (res < 0) {
+                printf("error getting: %ls", hid_error(device));
+        }
+        else {
+                printf("(%d bytes)", res);
+        }
+        for (int i = 0; i < res; i++) {
+                if (i % 10 == 0) {
+                        printf("\n");
+                }
+                printf("0x%02x, ", descriptor[i]);
+        }
+        printf("\n");
+}
+
+void print_hid_report_descriptor_from_path(const char *path) {
+        hid_device *device = hid_open_path(path);
+        if (device) {
+                print_hid_report_descriptor_from_device(device);
+                hid_close(device);
+        }
+        else {
+                printf("  Report Descriptor: Unable to open device by path\n");
+        }
+}
+
+void print_devices(struct hid_device_info *cur_dev) {
+        for (; cur_dev; cur_dev = cur_dev->next) {
+                print_device(cur_dev);
+        }
+}
+
+void print_devices_with_descriptor(struct hid_device_info *cur_dev) {
+        for (; cur_dev; cur_dev = cur_dev->next) {
+                print_device(cur_dev);
+                print_hid_report_descriptor_from_path(cur_dev->path);
+        }
+}
+
+int main(int argc, char* argv[])
+{
+        (void)argc;
+        (void)argv;
+
+        int res;
+        unsigned char buf[256];
+        #define MAX_STR 255
+        wchar_t wstr[MAX_STR];
+        hid_device *handle;
+        int i;
+
+        struct hid_device_info *devs;
+
+        printf("hidapi test/example tool. Compiled with hidapi version %s, runtime version %s.\n", HID_API_VERSION_STR, hid_version_str());
+        if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) {
+                printf("Compile-time version matches runtime version of hidapi.\n\n");
+        }
+        else {
+                printf("Compile-time version is different than runtime version of hidapi.\n]n");
+        }
+
+        if (hid_init())
+                return -1;
+
+#if defined(__APPLE__) && HID_API_VERSION >= HID_API_MAKE_VERSION(0, 12, 0)
+        // To work properly needs to be called before hid_open/hid_open_path after hid_init.
+        // Best/recommended option - call it right after hid_init.
+        hid_darwin_set_open_exclusive(0);
+#endif
+
+        devs = hid_enumerate(0x0, 0x0);
+        print_devices_with_descriptor(devs);
+        hid_free_enumeration(devs);
+
+        // Set up the command buffer.
+        memset(buf,0x00,sizeof(buf));
+        buf[0] = 0x01;
+        buf[1] = 0x81;
+
+
+        // Open the device using the VID, PID,
+        // and optionally the Serial number.
+        ////handle = hid_open(0x4d8, 0x3f, L"12345");
+        handle = hid_open(0x4d8, 0x3f, NULL);
+        if (!handle) {
+                printf("unable to open device\n");
+                hid_exit();
+                return 1;
+        }
+
+        // Read the Manufacturer String
+        wstr[0] = 0x0000;
+        res = hid_get_manufacturer_string(handle, wstr, MAX_STR);
+        if (res < 0)
+                printf("Unable to read manufacturer string\n");
+        printf("Manufacturer String: %ls\n", wstr);
+
+        // Read the Product String
+        wstr[0] = 0x0000;
+        res = hid_get_product_string(handle, wstr, MAX_STR);
+        if (res < 0)
+                printf("Unable to read product string\n");
+        printf("Product String: %ls\n", wstr);
+
+        // Read the Serial Number String
+        wstr[0] = 0x0000;
+        res = hid_get_serial_number_string(handle, wstr, MAX_STR);
+        if (res < 0)
+                printf("Unable to read serial number string\n");
+        printf("Serial Number String: (%d) %ls\n", wstr[0], wstr);
+
+        print_hid_report_descriptor_from_device(handle);
+
+        struct hid_device_info* info = hid_get_device_info(handle);
+        if (info == NULL) {
+                printf("Unable to get device info\n");
+        } else {
+                print_devices(info);
+        }
+
+        // Read Indexed String 1
+        wstr[0] = 0x0000;
+        res = hid_get_indexed_string(handle, 1, wstr, MAX_STR);
+        if (res < 0)
+                printf("Unable to read indexed string 1\n");
+        printf("Indexed String 1: %ls\n", wstr);
+
+        // Set the hid_read() function to be non-blocking.
+        hid_set_nonblocking(handle, 1);
+
+        // Try to read from the device. There should be no
+        // data here, but execution should not block.
+        res = hid_read(handle, buf, 17);
+
+        // Send a Feature Report to the device
+        buf[0] = 0x2;
+        buf[1] = 0xa0;
+        buf[2] = 0x0a;
+        buf[3] = 0x00;
+        buf[4] = 0x00;
+        res = hid_send_feature_report(handle, buf, 17);
+        if (res < 0) {
+                printf("Unable to send a feature report.\n");
+        }
+
+        memset(buf,0,sizeof(buf));
+
+        // Read a Feature Report from the device
+        buf[0] = 0x2;
+        res = hid_get_feature_report(handle, buf, sizeof(buf));
+        if (res < 0) {
+                printf("Unable to get a feature report: %ls\n", hid_error(handle));
+        }
+        else {
+                // Print out the returned buffer.
+                printf("Feature Report\n   ");
+                for (i = 0; i < res; i++)
+                        printf("%02x ", (unsigned int) buf[i]);
+                printf("\n");
+        }
+
+        memset(buf,0,sizeof(buf));
+
+        // Toggle LED (cmd 0x80). The first byte is the report number (0x1).
+        buf[0] = 0x1;
+        buf[1] = 0x80;
+        res = hid_write(handle, buf, 17);
+        if (res < 0) {
+                printf("Unable to write(): %ls\n", hid_error(handle));
+        }
+
+
+        // Request state (cmd 0x81). The first byte is the report number (0x1).
+        buf[0] = 0x1;
+        buf[1] = 0x81;
+        hid_write(handle, buf, 17);
+        if (res < 0) {
+                printf("Unable to write()/2: %ls\n", hid_error(handle));
+        }
+
+        // Read requested state. hid_read() has been set to be
+        // non-blocking by the call to hid_set_nonblocking() above.
+        // This loop demonstrates the non-blocking nature of hid_read().
+        res = 0;
+        i = 0;
+        while (res == 0) {
+                res = hid_read(handle, buf, sizeof(buf));
+                if (res == 0) {
+                        printf("waiting...\n");
+                }
+                if (res < 0) {
+                        printf("Unable to read(): %ls\n", hid_error(handle));
+                        break;
+                }
+
+                i++;
+                if (i >= 10) { /* 10 tries by 500 ms - 5 seconds of waiting*/
+                        printf("read() timeout\n");
+                        break;
+                }
+
+#ifdef _WIN32
+                Sleep(500);
+#else
+                usleep(500*1000);
+#endif
+        }
+
+        if (res > 0) {
+                printf("Data read:\n   ");
+                // Print out the returned buffer.
+                for (i = 0; i < res; i++)
+                        printf("%02x ", (unsigned int) buf[i]);
+                printf("\n");
+        }
+
+        hid_close(handle);
+
+        /* Free static HIDAPI objects. */
+        hid_exit();
+
+#ifdef _WIN32
+        system("pause");
+#endif
+
+        return 0;
+}