We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

Prototype of the C/loadso port

SDL_hidapi.c (text/x-csrc), 19.77 KB, created by Ethan Lee on 2019-03-17 19:18:02 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ethan Lee

Created: 2019-03-17 19:18:02 UTC

Size: 19.77 KB

patch

obsolete

>/*
>  Simple DirectMedia Layer
>  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
>
>  This software is provided 'as-is', without any express or implied
>  warranty.  In no event will the authors be held liable for any damages
>  arising from the use of this software.
>
>  Permission is granted to anyone to use this software for any purpose,
>  including commercial applications, and to alter it and redistribute it
>  freely, subject to the following restrictions:
>
>  1. The origin of this software must not be misrepresented; you must not
>     claim that you wrote the original software. If you use this software
>     in a product, an acknowledgment in the product documentation would be
>     appreciated but is not required.
>  2. Altered source versions must be plainly marked as such, and must not be
>     misrepresented as being the original software.
>  3. This notice may not be removed or altered from any source distribution.
>*/
>
>#include "../SDL_internal.h"
>#include "SDL_loadso.h"
>
>#ifdef SDL_JOYSTICK_HIDAPI
>
>/* libusb HIDAPI Implementation */
>
>/* Include this now, for our dynamically-loaded libusb context */
>#include <libusb.h>
>
>#if __LINUX__
>#define LIBUSB_DYNAMIC_LIB "libusb-1.0.so.0.1.0"
>#elif __MACOSX__
>#define LIBUSB_DYNAMIC_LIB "libusb-1.0.0.dylib"
>#elif __WINDOWS__
>#define LIBUSB_DYNAMIC_LIB "libusb-1.0.dll"
>#else
>#error Need a LIBUSB_DYNAMIC_LIB for this platform!
>#endif
>
>static struct
>{
>	void* libhandle;
>
>	int (*init)(libusb_context **ctx);
>	void (*exit)(libusb_context *ctx);
>	ssize_t (*get_device_list)(libusb_context *ctx, libusb_device ***list);
>	void (*free_device_list)(libusb_device **list, int unref_devices);
>	int (*get_device_descriptor)(libusb_device *dev, struct libusb_device_descriptor *desc);
>	int (*get_active_config_descriptor)(libusb_device *dev,	struct libusb_config_descriptor **config);
>	int (*get_config_descriptor)(
>		libusb_device *dev,
>		uint8_t config_index,
>		struct libusb_config_descriptor **config
>	);
>	void (*free_config_descriptor)(struct libusb_config_descriptor *config);
>	uint8_t (*get_bus_number)(libusb_device *dev);
>	uint8_t (*get_device_address)(libusb_device *dev);
>	int (*open)(libusb_device *dev, libusb_device_handle **dev_handle);
>	void (*close)(libusb_device_handle *dev_handle);
>	int (*claim_interface)(libusb_device_handle *dev_handle, int interface_number);
>	int (*release_interface)(libusb_device_handle *dev_handle, int interface_number);
>	int (*kernel_driver_active)(libusb_device_handle *dev_handle, int interface_number);
>	int (*detach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
>	struct libusb_transfer * (*alloc_transfer)(int iso_packets);
>	int (*submit_transfer)(struct libusb_transfer *transfer);
>	int (*cancel_transfer)(struct libusb_transfer *transfer);
>	void (*free_transfer)(struct libusb_transfer *transfer);
>	int (*control_transfer)(
>		libusb_device_handle *dev_handle,
>		uint8_t request_type,
>		uint8_t bRequest,
>		uint16_t wValue,
>		uint16_t wIndex,
>		unsigned char *data,
>		uint16_t wLength,
>		unsigned int timeout
>	);
>	int (*interrupt_transfer)(
>		libusb_device_handle *dev_handle,
>		unsigned char endpoint,
>		unsigned char *data,
>		int length,
>		int *actual_length,
>		unsigned int timeout
>	);
>	int (*handle_events)(libusb_context *ctx);
>	int (*handle_events_completed)(libusb_context *ctx, int *completed);
>} libusb_ctx;
>
>#define libusb_init				libusb_ctx.init
>#define libusb_exit				libusb_ctx.exit
>#define libusb_get_device_list			libusb_ctx.get_device_list
>#define libusb_free_device_list			libusb_ctx.free_device_list
>#define libusb_get_device_descriptor		libusb_ctx.get_device_descriptor
>#define libusb_get_active_config_descriptor	libusb_ctx.get_active_config_descriptor
>#define libusb_get_config_descriptor		libusb_ctx.get_config_descriptor
>#define libusb_free_config_descriptor		libusb_ctx.free_config_descriptor
>#define libusb_get_bus_number			libusb_ctx.get_bus_number
>#define libusb_get_device_address		libusb_ctx.get_device_address
>#define libusb_open				libusb_ctx.open
>#define libusb_close				libusb_ctx.close
>#define libusb_claim_interface			libusb_ctx.claim_interface
>#define libusb_release_interface		libusb_ctx.release_interface
>#define libusb_kernel_driver_active		libusb_ctx.kernel_driver_active
>#define libusb_detach_kernel_driver		libusb_ctx.detach_kernel_driver
>#define libusb_alloc_transfer			libusb_ctx.alloc_transfer
>#define libusb_submit_transfer			libusb_ctx.submit_transfer
>#define libusb_cancel_transfer			libusb_ctx.cancel_transfer
>#define libusb_free_transfer			libusb_ctx.free_transfer
>#define libusb_control_transfer			libusb_ctx.control_transfer
>#define libusb_interrupt_transfer		libusb_ctx.interrupt_transfer
>#define libusb_handle_events			libusb_ctx.handle_events
>#define libusb_handle_events_completed		libusb_ctx.handle_events_completed
>
>#define hid_device_			LIBUSB_hid_device_
>#define hid_device			LIBUSB_hid_device
>#define hid_device_info			LIBUSB_hid_device_info
>#define hid_init			LIBUSB_hid_init
>#define hid_exit			LIBUSB_hid_exit
>#define hid_enumerate			LIBUSB_hid_enumerate
>#define hid_free_enumeration		LIBUSB_hid_free_enumeration
>#define hid_open			LIBUSB_hid_open
>#define hid_open_path			LIBUSB_hid_open_path
>#define hid_write			LIBUSB_hid_write
>#define hid_read_timeout		LIBUSB_hid_read_timeout
>#define hid_read			LIBUSB_hid_read
>#define hid_set_nonblocking		LIBUSB_hid_set_nonblocking
>#define hid_send_feature_report		LIBUSB_hid_send_feature_report
>#define hid_get_feature_report		LIBUSB_hid_get_feature_report
>#define hid_close			LIBUSB_hid_close
>#define hid_get_manufacturer_string	LIBUSB_hid_get_manufacturer_string
>#define hid_get_product_string		LIBUSB_hid_get_product_string
>#define hid_get_serial_number_string	LIBUSB_hid_get_serial_number_string
>#define hid_get_indexed_string		LIBUSB_hid_get_indexed_string
>#define hid_error			LIBUSB_hid_error
>#define new_hid_device			LIBUSB_new_hid_device
>
>#include "libusb/hid.c"
>
>#undef hid_device_
>#undef hid_device
>#undef hid_device_info
>#undef hid_init
>#undef hid_exit
>#undef hid_enumerate
>#undef hid_free_enumeration
>#undef hid_open
>#undef hid_open_path
>#undef hid_write
>#undef hid_read_timeout
>#undef hid_read
>#undef hid_set_nonblocking
>#undef hid_send_feature_report
>#undef hid_get_feature_report
>#undef hid_close
>#undef hid_get_manufacturer_string
>#undef hid_get_product_string
>#undef hid_get_serial_number_string
>#undef hid_get_indexed_string
>#undef hid_error
>#undef new_hid_device
>
>/* Platform HIDAPI Implementation */
>
>#define hid_device_			PLATFORM_hid_device_
>#define hid_device			PLATFORM_hid_device
>#define hid_device_info			PLATFORM_hid_device_info
>#define hid_init			PLATFORM_hid_init
>#define hid_exit			PLATFORM_hid_exit
>#define hid_enumerate			PLATFORM_hid_enumerate
>#define hid_free_enumeration		PLATFORM_hid_free_enumeration
>#define hid_open			PLATFORM_hid_open
>#define hid_open_path			PLATFORM_hid_open_path
>#define hid_write			PLATFORM_hid_write
>#define hid_read_timeout		PLATFORM_hid_read_timeout
>#define hid_read			PLATFORM_hid_read
>#define hid_set_nonblocking		PLATFORM_hid_set_nonblocking
>#define hid_send_feature_report		PLATFORM_hid_send_feature_report
>#define hid_get_feature_report		PLATFORM_hid_get_feature_report
>#define hid_close			PLATFORM_hid_close
>#define hid_get_manufacturer_string	PLATFORM_hid_get_manufacturer_string
>#define hid_get_product_string		PLATFORM_hid_get_product_string
>#define hid_get_serial_number_string	PLATFORM_hid_get_serial_number_string
>#define hid_get_indexed_string		PLATFORM_hid_get_indexed_string
>#define hid_error			PLATFORM_hid_error
>#define new_hid_device			PLATFORM_new_hid_device
>
>#undef HIDAPI_H__
>#if __LINUX__
>#include "linux/hid.c"
>#elif __MACOSX__
>#include "mac/hid.c"
>#elif __WINDOWS__
>#include "windows/hid.c"
>#else
>#error Need a hid.c for this platform!
>#endif
>
>#undef hid_device_
>#undef hid_device
>#undef hid_device_info
>#undef hid_init
>#undef hid_exit
>#undef hid_enumerate
>#undef hid_free_enumeration
>#undef hid_open
>#undef hid_open_path
>#undef hid_write
>#undef hid_read_timeout
>#undef hid_read
>#undef hid_set_nonblocking
>#undef hid_send_feature_report
>#undef hid_get_feature_report
>#undef hid_close
>#undef hid_get_manufacturer_string
>#undef hid_get_product_string
>#undef hid_get_serial_number_string
>#undef hid_get_indexed_string
>#undef hid_error
>#undef new_hid_device
>
>/* Shared HIDAPI Implementation */
>
>#undef HIDAPI_H__
>#include "hidapi.h"
>
>typedef enum
>{
>	HIDDeviceType_UNKNOWN,
>	HIDDeviceType_LIBUSB,
>	HIDDeviceType_PLATFORM
>} HIDDeviceType;
>
>typedef struct _HIDDeviceEntry HIDDeviceEntry;
>struct _HIDDeviceEntry
>{
>	hid_device *device;
>	HIDDeviceType type;
>	HIDDeviceEntry *next;
>};
>
>static HIDDeviceEntry *devlist;
>
>static HIDDeviceType GetAPIForDevice(hid_device *device)
>{
>	HIDDeviceEntry *entry = devlist;
>	while (entry != NULL)
>	{
>		if (entry->device == device)
>		{
>			return entry->type;
>		}
>	}
>	return HIDDeviceType_UNKNOWN;
>}
>
>static void AddHIDDevice(hid_device *device, HIDDeviceType type)
>{
>	HIDDeviceEntry *entry, *list;
>	entry = (HIDDeviceEntry*) SDL_malloc(sizeof(HIDDeviceEntry));
>	entry->device = device;
>	entry->type = type;
>	entry->next = NULL;
>	if (devlist == NULL)
>	{
>		devlist = entry;
>	}
>	else
>	{
>		list = devlist;
>		while (list->next != NULL)
>		{
>			list = list->next;
>		}
>		list->next = entry;
>	}
>}
>
>static void DeleteHIDDevice(hid_device *device)
>{
>	HIDDeviceEntry *prev = NULL, *entry = devlist;
>	while (entry != NULL)
>	{
>		if (entry->device == device)
>		{
>			if (prev == NULL)
>			{
>				devlist = entry->next;
>			}
>			else
>			{
>				prev->next = entry->next;
>			}
>			SDL_free(entry);
>			return;
>		}
>		prev = entry;
>		entry->next;
>	}
>}
>
>static void LIBUSB_CopyHIDDeviceInfo(
>	struct LIBUSB_hid_device_info *pSrc,
>	struct hid_device_info *pDst
>) {
>	pDst->path = pSrc->path ? SDL_strdup(pSrc->path) : NULL;
>	pDst->vendor_id = pSrc->vendor_id;
>	pDst->product_id = pSrc->product_id;
>	pDst->serial_number = pSrc->serial_number ? SDL_wcsdup(pSrc->serial_number) : NULL;
>	pDst->release_number = pSrc->release_number;
>	pDst->manufacturer_string = pSrc->manufacturer_string ?
>		SDL_wcsdup(pSrc->manufacturer_string) : NULL;
>	pDst->product_string = pSrc->product_string ? SDL_wcsdup(pSrc->product_string) : NULL;
>	pDst->usage_page = pSrc->usage_page;
>	pDst->usage = pSrc->usage;
>	pDst->interface_number = pSrc->interface_number;
>	pDst->next = NULL;
>}
>
>static void PLATFORM_CopyHIDDeviceInfo(
>	struct PLATFORM_hid_device_info *pSrc,
>	struct hid_device_info *pDst
>) {
>	pDst->path = pSrc->path ? SDL_strdup(pSrc->path) : NULL;
>	pDst->vendor_id = pSrc->vendor_id;
>	pDst->product_id = pSrc->product_id;
>	pDst->serial_number = pSrc->serial_number ? SDL_wcsdup(pSrc->serial_number) : NULL;
>	pDst->release_number = pSrc->release_number;
>	pDst->manufacturer_string = pSrc->manufacturer_string ?
>		SDL_wcsdup(pSrc->manufacturer_string) : NULL;
>	pDst->product_string = pSrc->product_string ? SDL_wcsdup(pSrc->product_string) : NULL;
>	pDst->usage_page = pSrc->usage_page;
>	pDst->usage = pSrc->usage;
>	pDst->interface_number = pSrc->interface_number;
>	pDst->next = NULL;
>}
>
>int HID_API_EXPORT HID_API_CALL hid_init(void)
>{
>	int err;
>
>	libusb_ctx.libhandle = SDL_LoadObject(LIBUSB_DYNAMIC_LIB);
>	if (libusb_ctx.libhandle == NULL)
>	{
>		return SDL_SetError("Failed to initialize libusb!");
>	}
>	#define LOAD_LIBUSB_SYMBOL(func) \
>		libusb_ctx.func = SDL_LoadFunction(libusb_ctx.libhandle, "libusb_" #func);
>	LOAD_LIBUSB_SYMBOL(init)
>	LOAD_LIBUSB_SYMBOL(exit)
>	LOAD_LIBUSB_SYMBOL(get_device_list)
>	LOAD_LIBUSB_SYMBOL(free_device_list)
>	LOAD_LIBUSB_SYMBOL(get_device_descriptor)
>	LOAD_LIBUSB_SYMBOL(get_active_config_descriptor)
>	LOAD_LIBUSB_SYMBOL(get_config_descriptor)
>	LOAD_LIBUSB_SYMBOL(free_config_descriptor)
>	LOAD_LIBUSB_SYMBOL(get_bus_number)
>	LOAD_LIBUSB_SYMBOL(get_device_address)
>	LOAD_LIBUSB_SYMBOL(open)
>	LOAD_LIBUSB_SYMBOL(close)
>	LOAD_LIBUSB_SYMBOL(claim_interface)
>	LOAD_LIBUSB_SYMBOL(release_interface)
>	LOAD_LIBUSB_SYMBOL(kernel_driver_active)
>	LOAD_LIBUSB_SYMBOL(detach_kernel_driver)
>	LOAD_LIBUSB_SYMBOL(alloc_transfer)
>	LOAD_LIBUSB_SYMBOL(submit_transfer)
>	LOAD_LIBUSB_SYMBOL(cancel_transfer)
>	LOAD_LIBUSB_SYMBOL(free_transfer)
>	LOAD_LIBUSB_SYMBOL(control_transfer)
>	LOAD_LIBUSB_SYMBOL(interrupt_transfer)
>	LOAD_LIBUSB_SYMBOL(handle_events)
>	LOAD_LIBUSB_SYMBOL(handle_events_completed)
>	#undef LOAD_LIBUSB_SYMBOL
>
>	if ((err = LIBUSB_hid_init()) < 0)
>	{
>		SDL_UnloadObject(libusb_ctx.libhandle);
>		return err;
>	}
>	if ((err = PLATFORM_hid_init()) < 0)
>	{
>		SDL_UnloadObject(libusb_ctx.libhandle);
>		return err;
>	}
>
>	devlist = NULL;
>	return 0;
>}
>
>int HID_API_EXPORT HID_API_CALL hid_exit(void)
>{
>	int LIBUSB_err, PLATFORM_err;
>	LIBUSB_err = LIBUSB_hid_exit();
>	PLATFORM_err = PLATFORM_hid_exit();
>	SDL_UnloadObject(libusb_ctx.libhandle);
>	return LIBUSB_err | PLATFORM_err; /* Ehhhhh */
>}
>
>struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
>{
>	struct LIBUSB_hid_device_info *usb_devs = LIBUSB_hid_enumerate(vendor_id, product_id);
>	struct LIBUSB_hid_device_info *usb_dev;
>	struct PLATFORM_hid_device_info *raw_devs = PLATFORM_hid_enumerate(vendor_id, product_id);
>	struct PLATFORM_hid_device_info *raw_dev;
>	struct hid_device_info *devs = NULL, *last = NULL, *new_dev;
>	SDL_bool bFound;
>
>	for (usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next)
>	{
>		bFound = SDL_FALSE;
>		for (raw_dev = raw_devs; raw_dev; raw_dev = raw_dev->next)
>		{
>			if (	usb_dev->vendor_id == raw_dev->vendor_id &&
>				usb_dev->product_id == raw_dev->product_id	)
>			{
>				bFound = SDL_TRUE;
>				break;
>			}
>		}
>
>		if (!bFound)
>		{
>			new_dev = (struct hid_device_info*) SDL_malloc(sizeof(struct hid_device_info));
>			LIBUSB_CopyHIDDeviceInfo(usb_dev, new_dev);
>
>			if (last != NULL)
>			{
>				last->next = new_dev;
>			}
>			else
>			{
>				devs = new_dev;
>			}
>			last = new_dev;
>		}
>	}
>	LIBUSB_hid_free_enumeration(usb_devs);
>
>	for (raw_dev = raw_devs; raw_dev; raw_dev = raw_dev->next)
>	{
>		new_dev = (struct hid_device_info*) SDL_malloc(sizeof(struct hid_device_info));
>		PLATFORM_CopyHIDDeviceInfo(raw_dev, new_dev);
>		new_dev->next = NULL;
>
>		if (last != NULL)
>		{
>			last->next = new_dev;
>		}
>		else
>		{
>			devs = new_dev;
>		}
>		last = new_dev;
>	}
>	PLATFORM_hid_free_enumeration(raw_devs);
>
>	return devs;
>}
>
>void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
>{
>	while (devs)
>	{
>		struct hid_device_info *next = devs->next;
>		SDL_free(devs->path);
>		SDL_free(devs->serial_number);
>		SDL_free(devs->manufacturer_string);
>		SDL_free(devs->product_string);
>		SDL_free(devs);
>		devs = next;
>	}
>}
>
>HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
>{
>	hid_device *pDevice = NULL;
>	if ((pDevice = (hid_device*) PLATFORM_hid_open(vendor_id, product_id, serial_number)) != NULL)
>	{
>		AddHIDDevice(pDevice, HIDDeviceType_PLATFORM);
>	}
>	if ((pDevice = (hid_device*) LIBUSB_hid_open(vendor_id, product_id, serial_number)) != NULL)
>	{
>		AddHIDDevice(pDevice, HIDDeviceType_LIBUSB);
>	}
>	return pDevice;
>}
>
>HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bExclusive /* = false */)
>{
>	hid_device *pDevice = NULL;
>	if ((pDevice = (hid_device*) PLATFORM_hid_open_path(path, bExclusive)) != NULL)
>	{
>		AddHIDDevice(pDevice, HIDDeviceType_PLATFORM);
>	}
>	if ((pDevice = (hid_device*) LIBUSB_hid_open_path(path, bExclusive)) != NULL)
>	{
>		AddHIDDevice(pDevice, HIDDeviceType_LIBUSB);
>	}
>	return pDevice;
>}
>
>int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_write((PLATFORM_hid_device*) device, data, length);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_write((LIBUSB_hid_device*) device, data, length);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_read_timeout(
>			(PLATFORM_hid_device*) device,
>			data,
>			length,
>			milliseconds
>		);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_read_timeout(
>			(LIBUSB_hid_device*) device,
>			data,
>			length,
>			milliseconds
>		);
>	default:
>		return -1;
>	}
>}
>
>int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_read((PLATFORM_hid_device*) device, data, length);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_read((LIBUSB_hid_device*) device, data, length);
>	default:
>		return -1;
>	}
>}
>
>int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_set_nonblocking((PLATFORM_hid_device*) device, nonblock);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_set_nonblocking((LIBUSB_hid_device*) device, nonblock);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_send_feature_report((PLATFORM_hid_device*) device, data, length);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_send_feature_report((LIBUSB_hid_device*) device, data, length);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_get_feature_report((PLATFORM_hid_device*) device, data, length);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_get_feature_report((LIBUSB_hid_device*) device, data, length);
>	default:
>		return -1;
>	}
>}
>
>void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		PLATFORM_hid_close((PLATFORM_hid_device*) device);
>		break;
>	case HIDDeviceType_LIBUSB:
>		LIBUSB_hid_close((LIBUSB_hid_device*) device);
>		break;
>	default:
>		break;
>	}
>	DeleteHIDDevice(device);
>}
>
>int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_get_manufacturer_string(
>			(PLATFORM_hid_device*) device,
>			string,
>			maxlen
>		);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_get_manufacturer_string(
>			(LIBUSB_hid_device*) device,
>			string,
>			maxlen
>		);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_get_product_string((PLATFORM_hid_device*) device, string, maxlen);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_get_product_string((LIBUSB_hid_device*) device, string, maxlen);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_get_serial_number_string(
>			(PLATFORM_hid_device*) device,
>			string,
>			maxlen
>		);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_get_serial_number_string(
>			(LIBUSB_hid_device*) device,
>			string,
>			maxlen
>		);
>	default:
>		return -1;
>	}
>}
>
>int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_get_indexed_string(
>			(PLATFORM_hid_device*) device,
>			string_index,
>			string,
>			maxlen
>		);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_get_indexed_string(
>			(LIBUSB_hid_device*) device,
>			string_index,
>			string,
>			maxlen
>		);
>	default:
>		return -1;
>	}
>}
>
>HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device)
>{
>	switch (GetAPIForDevice(device))
>	{
>	case HIDDeviceType_PLATFORM:
>		return PLATFORM_hid_error((PLATFORM_hid_device*) device);
>	case HIDDeviceType_LIBUSB:
>		return LIBUSB_hid_error((LIBUSB_hid_device*) device);
>	default:
>		return NULL;
>	}
>}
>
>#endif /* SDL_JOYSTICK_HIDAPI */

Actions: View

Attachments on bug 4554: 3700 | 3897 | 3913 | 3915 | 3917 | 3919 | 3921

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.