Merge lp:~hile/mixxx/hotplug into lp:~mixxxdevelopers/mixxx/trunk

[Ilkka Tuohela]

This branch changes controller manager device setup code so that the device setup function can be called on running system to implement hotplugging of controllers, and adds basic support to implement hotplugging in the backends.

It also implements HID hotplugging, removing and adding devices with a timer when devices are disconnected and connected. I have been running this hotplug code now for months, and after I fixed an error in the controller manager (preset was loaded every time changes were detected, causing multiple instances of same preset), it now seems to be very solid for HID devices.

For MIDI devices, the portmidi enumerator is changed to just return if devices were already loaded: until portmidi supports hotplug or we implement a new MIDI backend with something else than portmidi, this is the only thing we can do for MIDI.

If this is considered too late for 1.11, please merge the code at least to trunk.

[lp:~hile/mixxx/hotplug]

3293. By Ilkka Tuohela on 2012-08-26

Merge from trunk

Unmerged revisions

3293. By Ilkka Tuohela on 2012-08-26

Merge from trunk

3292. By Ilkka Tuohela on 2012-08-06

Merge from trunk

3291. By Ilkka Tuohela on 2012-07-30

Import changes to HID API

=== modified file 'mixxx/build/features.py'
--- mixxx/build/features.py	2012-07-08 07:30:32 +0000
+++ mixxx/build/features.py	2012-08-26 04:54:21 +0000
@@ -51,7 +51,7 @@
                 'controllers/midi/hss1394enumerator.cpp']
 
 class HID(Feature):
-    HIDAPI_INTERNAL_PATH = '#lib/hidapi-0.7.0'
+    HIDAPI_INTERNAL_PATH = '#lib/hidapi'
     def description(self):
         return "HID controller support"
 
@@ -97,7 +97,7 @@
         if build.platform_is_windows:
             # Requires setupapi.lib which is included by the above check for
             # setupapi.
-            sources.append("#lib/hidapi-0.7.0/windows/hid.c")
+            sources.append("#lib/hidapi/windows/hid.c")
             return sources
         elif build.platform_is_linux:
             sources.append(os.path.join(self.HIDAPI_INTERNAL_PATH, 'linux/hid-libusb.c'))

=== renamed directory 'mixxx/lib/hidapi-0.7.0' => 'mixxx/lib/hidapi'
=== modified file 'mixxx/lib/hidapi/hidapi/hidapi.h'
--- mixxx/lib/hidapi-0.7.0/hidapi/hidapi.h	2012-01-28 09:23:48 +0000
+++ mixxx/lib/hidapi/hidapi/hidapi.h	2012-08-26 04:54:21 +0000
@@ -155,7 +155,7 @@
 				This function returns a pointer to a #hid_device object on
 				success or NULL on failure.
 		*/
-		HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number);
+		HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
 
 		/** @brief Open a HID device by its path name.
 

=== modified file 'mixxx/lib/hidapi/linux/hid-libusb.c'
--- mixxx/lib/hidapi-0.7.0/linux/hid-libusb.c	2012-05-12 10:43:43 +0000
+++ mixxx/lib/hidapi/linux/hid-libusb.c	2012-08-26 04:54:21 +0000
@@ -8,6 +8,7 @@
  8/22/2009
  Linux Version - 6/2/2010
  Libusb Version - 8/13/2010
+ FreeBSD Version - 11/1/2011
 
  Copyright 2009, All Rights Reserved.
  
@@ -58,11 +59,15 @@
 #define LOG(...) do {} while (0)
 #endif
 
+#ifndef __FreeBSD__
+#define DETACH_KERNEL_DRIVER
+#endif
 
 /* Uncomment to enable the retrieval of Usage and Usage Page in
-hid_enumerate(). Warning, this is very invasive as it requires the detach
+hid_enumerate(). Warning, on platforms different from FreeBSD
+this is very invasive as it requires the detach
 and re-attach of the kernel driver. See comments inside hid_enumerate().
-Linux/libusb HIDAPI programs are encouraged to use the interface number
+libusb HIDAPI programs are encouraged to use the interface number
 instead to differentiate between interfaces on a composite HID device. */
 /*#define INVASIVE_GET_USAGE*/
 
@@ -106,7 +111,7 @@
 	struct input_report *input_reports;
 };
 
-static int initialized = 0;
+static libusb_context *usb_context = NULL;
 
 uint16_t get_usb_code_for_current_locale(void);
 static int return_data(hid_device *dev, unsigned char *data, size_t length);
@@ -114,18 +119,7 @@
 static hid_device *new_hid_device(void)
 {
 	hid_device *dev = calloc(1, sizeof(hid_device));
-	dev->device_handle = NULL;
-	dev->input_endpoint = 0;
-	dev->output_endpoint = 0;
-	dev->input_ep_max_packet_size = 0;
-	dev->interface = 0;
-	dev->manufacturer_index = 0;
-	dev->product_index = 0;
-	dev->serial_index = 0;
 	dev->blocking = 1;
-	dev->shutdown_thread = 0;
-	dev->transfer = NULL;
-	dev->input_reports = NULL;
 	
 	pthread_mutex_init(&dev->mutex, NULL);
 	pthread_cond_init(&dev->condition, NULL);
@@ -146,7 +140,7 @@
 }
 
 #if 0
-//TODO: Implement this funciton on Linux.
+//TODO: Implement this funciton on hidapi/libusb..
 static void register_error(hid_device *device, const char *op)
 {
 
@@ -255,6 +249,27 @@
 }
 #endif // INVASIVE_GET_USAGE
 
+#ifdef __FreeBSD__
+/* The FreeBSD version of libusb doesn't have this funciton. In mainline
+   libusb, it's inlined in libusb.h. This function will bear a striking
+   resemblence to that one, because there's about one way to code it.
+
+   Note that the data parameter is Unicode in UTF-16LE encoding.
+   Return value is the number of bytes in data, or LIBUSB_ERROR_*.
+ */
+static inline int libusb_get_string_descriptor(libusb_device_handle *dev,
+	uint8_t descriptor_index, uint16_t lang_id,
+	unsigned char *data, int length)
+{
+	return libusb_control_transfer(dev,
+		LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
+		LIBUSB_REQUEST_GET_DESCRIPTOR,
+		(LIBUSB_DT_STRING << 8) | descriptor_index,
+		lang_id, data, (uint16_t) length, 1000);
+}
+
+#endif
+
 
 /* Get the first language the device says it reports. This comes from
    USB string #0. */
@@ -317,7 +332,11 @@
 	size_t inbytes;
 	size_t outbytes;
 	size_t res;
+#ifdef __FreeBSD__
+	const char *inptr;
+#else
 	char *inptr;
+#endif
 	char *outptr;
 
 	/* Determine which language to use. */
@@ -335,25 +354,27 @@
 	if (len < 0)
 		return NULL;
 	
-	buf[sizeof(buf)-1] = '\0';
-	
-	if (len+1 < sizeof(buf))
-		buf[len+1] = '\0';
+	/* buf does not need to be explicitly NULL-terminated because
+	   it is only passed into iconv() which does not need it. */
 	
 	/* Initialize iconv. */
-	ic = iconv_open("UTF-32", "UTF-16");
-	if (ic == (iconv_t)-1)
+	ic = iconv_open("WCHAR_T", "UTF-16LE");
+	if (ic == (iconv_t)-1) {
+		LOG("iconv_open() failed\n");
 		return NULL;
+	}
 	
-	/* Convert to UTF-32 (wchar_t on glibc systems).
+	/* Convert to native wchar_t (UTF-32 on glibc/BSD systems).
 	   Skip the first character (2-bytes). */
 	inptr = buf+2;
 	inbytes = len-2;
 	outptr = (char*) wbuf;
 	outbytes = sizeof(wbuf);
 	res = iconv(ic, &inptr, &inbytes, &outptr, &outbytes);
-	if (res == (size_t)-1)
+	if (res == (size_t)-1) {
+		LOG("iconv() failed\n");
 		goto err;
+	}
 
 	/* Write the terminating NULL. */
 	wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
@@ -361,7 +382,7 @@
 		*((wchar_t*)outptr) = 0x00000000;
 	
 	/* Allocate and copy the string. */
-	str = wcsdup(wbuf+1);
+	str = wcsdup(wbuf);
 
 err:
 	iconv_close(ic);
@@ -384,10 +405,17 @@
 
 int HID_API_EXPORT hid_init(void)
 {
-	if (!initialized) {
-		if (libusb_init(NULL))
+	if (!usb_context) {
+		const char *locale;
+
+		/* Init Libusb */
+		if (libusb_init(&usb_context))
 			return -1;
-		initialized = 1;
+
+		/* Set the locale if it's not set. */
+		locale = setlocale(LC_CTYPE, NULL);
+		if (!locale)
+			setlocale(LC_CTYPE, "");
 	}
 
 	return 0;
@@ -395,9 +423,9 @@
 
 int HID_API_EXPORT hid_exit(void)
 {
-	if (initialized) {
-		libusb_exit(NULL);
-		initialized = 0;
+	if (usb_context) {
+		libusb_exit(usb_context);
+		usb_context = NULL;
 	}
 
 	return 0;
@@ -414,12 +442,9 @@
 	struct hid_device_info *root = NULL; // return object
 	struct hid_device_info *cur_dev = NULL;
 	
-	setlocale(LC_ALL,"");
-	
-	if (!initialized)
-		hid_init();
+	hid_init();
 
-	num_devs = libusb_get_device_list(NULL, &devs);
+	num_devs = libusb_get_device_list(usb_context, &devs);
 	if (num_devs < 0)
 		return NULL;
 	while ((dev = devs[i++]) != NULL) {
@@ -499,9 +524,9 @@
 							#if 0. For composite devices, use the interface
 							field in the hid_device_info struct to distinguish
 							between interfaces. */
+								unsigned char data[256];
+#ifdef DETACH_KERNEL_DRIVER
 								int detached = 0;
-								unsigned char data[256];
-							
 								/* Usage Page and Usage */
 								res = libusb_kernel_driver_active(handle, interface_num);
 								if (res == 1) {
@@ -511,6 +536,7 @@
 									else
 										detached = 1;
 								}
+#endif
 								res = libusb_claim_interface(handle, interface_num);
 								if (res >= 0) {
 									/* Get the HID Report Descriptor. */
@@ -533,14 +559,16 @@
 								}
 								else
 									LOG("Can't claim interface %d\n", res);
-
+#ifdef DETACH_KERNEL_DRIVER
 								/* Re-attach kernel driver if necessary. */
 								if (detached) {
 									res = libusb_attach_kernel_driver(handle, interface_num);
 									if (res < 0)
 										LOG("Couldn't re-attach kernel driver.\n");
 								}
-#endif /*******************/
+#endif
+
+#endif // INVASIVE_GET_USAGE
 
 								libusb_close(handle);
 							}
@@ -580,7 +608,7 @@
 	}
 }
 
-hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
 	struct hid_device_info *devs, *cur_dev;
 	const char *path_to_open = NULL;
@@ -618,6 +646,7 @@
 static void read_callback(struct libusb_transfer *transfer)
 {
 	hid_device *dev = transfer->user_data;
+	int res;
 	
 	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
 
@@ -670,7 +699,11 @@
 	}
 	
 	/* Re-submit the transfer object. */
-	libusb_submit_transfer(transfer);
+	res = libusb_submit_transfer(transfer);
+	if (res != 0) {
+		LOG("Unable to submit URB. libusb error code: %d\n", res);
+		dev->shutdown_thread = 1;
+	}
 }
 
 
@@ -702,21 +735,16 @@
 	/* Handle all the events. */
 	while (!dev->shutdown_thread) {
 		int res;
-		res = libusb_handle_events(NULL);
+		res = libusb_handle_events(usb_context);
 		if (res < 0) {
 			/* There was an error. */
-			LOG("libusb reports error # %d\n", res);
-			/* Should call libusb_error_name() to get the string version but
-			   the compiler doesn't recognize that function for some reason */
+			LOG("read_thread(): libusb reports error # %d\n", res);
 
-			/* Break out of this loop only on fatal error conditions.
-			   See the list at:
-			   http://libusb.sourceforge.net/api-1.0/group__misc.html#gab2323aa0f04bc22038e7e1740b2f29ef
-			   */
+			/* Break out of this loop only on fatal error.*/
 			if (res != LIBUSB_ERROR_BUSY &&
-				res != LIBUSB_ERROR_TIMEOUT &&
-				res != LIBUSB_ERROR_OVERFLOW &&
-				res != LIBUSB_ERROR_INTERRUPTED) {
+			    res != LIBUSB_ERROR_TIMEOUT &&
+			    res != LIBUSB_ERROR_OVERFLOW &&
+			    res != LIBUSB_ERROR_INTERRUPTED) {
 				break;
 			}
 		}
@@ -726,7 +754,7 @@
 	   if no transfers are pending, but that's OK. */
 	if (libusb_cancel_transfer(dev->transfer) == 0) {
 		/* The transfer was cancelled, so wait for its completion. */
-		libusb_handle_events(NULL);
+		libusb_handle_events(usb_context);
 	}
 	
 	/* Now that the read thread is stopping, Wake any threads which are
@@ -763,12 +791,9 @@
 	int d = 0;
 	int good_open = 0;
 	
-	setlocale(LC_ALL,"");
-	
-	if (!initialized)
-		hid_init();
+	hid_init();
 
-	num_devs = libusb_get_device_list(NULL, &devs);
+	num_devs = libusb_get_device_list(usb_context, &devs);
 	while ((usb_dev = devs[d++]) != NULL) {
 		struct libusb_device_descriptor desc;
 		struct libusb_config_descriptor *conf_desc = NULL;
@@ -795,7 +820,7 @@
  							break;
 						}
 						good_open = 1;
-						
+#ifdef DETACH_KERNEL_DRIVER
 						/* Detach the kernel driver, but only if the
 						   device is managed by the kernel */
 						if (libusb_kernel_driver_active(dev->device_handle, intf_desc->bInterfaceNumber) == 1) {
@@ -808,7 +833,7 @@
 								break;
 							}
 						}
-						
+#endif
 						res = libusb_claim_interface(dev->device_handle, intf_desc->bInterfaceNumber);
 						if (res < 0) {
 							LOG("can't claim interface %d: %d\n", intf_desc->bInterfaceNumber, res);

=== modified file 'mixxx/lib/hidapi/linux/hid.c'
--- mixxx/lib/hidapi-0.7.0/linux/hid.c	2012-01-28 09:23:48 +0000
+++ mixxx/lib/hidapi/linux/hid.c	2012-08-26 04:54:21 +0000
@@ -40,6 +40,7 @@
 /* Linux */
 #include <linux/hidraw.h>
 #include <linux/version.h>
+#include <linux/input.h>
 #include <libudev.h>
 
 #include "hidapi.h"
@@ -53,6 +54,23 @@
 #define HIDIOCGFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
 #endif
 
+
+/* USB HID device property names */
+const char *device_string_names[] = {
+	"manufacturer",
+	"product",
+	"serial",
+};
+
+/* Symbolic names for the properties above */
+enum device_string_id {
+	DEVICE_STRING_MANUFACTURER,
+	DEVICE_STRING_PRODUCT,
+	DEVICE_STRING_SERIAL,
+
+	DEVICE_STRING_COUNT,
+};
+
 struct hid_device_ {
 	int device_handle;
 	int blocking;
@@ -77,22 +95,29 @@
 
 }
 
+/* The caller must free the returned string with free(). */
+static wchar_t *utf8_to_wchar_t(const char *utf8)
+{
+	wchar_t *ret = NULL;
+
+	if (utf8) {
+		size_t wlen = mbstowcs(NULL, utf8, 0);
+		if (wlen < 0) {
+			return wcsdup(L"");
+		}
+		ret = calloc(wlen+1, sizeof(wchar_t));
+		mbstowcs(ret, utf8, wlen+1);
+		ret[wlen] = 0x0000;
+	}
+
+	return ret;
+}
+
 /* Get an attribute value from a udev_device and return it as a whar_t
    string. The returned string must be freed with free() when done.*/
 static wchar_t *copy_udev_string(struct udev_device *dev, const char *udev_name)
 {
-	const char *str;
-	wchar_t *ret = NULL;
-	str = udev_device_get_sysattr_value(dev, udev_name);
-	if (str) {
-		/* Convert the string from UTF-8 to wchar_t */
-		size_t wlen = mbstowcs(NULL, str, 0);
-		ret = calloc(wlen+1, sizeof(wchar_t));
-		mbstowcs(ret, str, wlen+1);
-		ret[wlen] = 0x0000;
-	}
-	
-	return ret;
+	return utf8_to_wchar_t(udev_device_get_sysattr_value(dev, udev_name));
 }
 
 /* uses_numbered_reports() returns 1 if report_descriptor describes a device
@@ -157,14 +182,70 @@
 	return 0;
 }
 
-static int get_device_string(hid_device *dev, const char *key, wchar_t *string, size_t maxlen)
+/*
+ * The caller is responsible for free()ing the (newly-allocated) character
+ * strings pointed to by serial_number_utf8 and product_name_utf8 after use.
+ */
+int
+parse_uevent_info(const char *uevent, int *bus_type,
+	unsigned short *vendor_id, unsigned short *product_id,
+	char **serial_number_utf8, char **product_name_utf8)
+{
+	char *tmp = strdup(uevent);
+	char *saveptr = NULL;
+	char *line;
+	char *key;
+	char *value;
+
+	int found_id = 0;
+	int found_serial = 0;
+	int found_name = 0;
+
+	line = strtok_r(tmp, "\n", &saveptr);
+	while (line != NULL) {
+		/* line: "KEY=value" */
+		key = line;
+		value = strchr(line, '=');
+		if (!value) {
+			goto next_line;
+		}
+		*value = '\0';
+		value++;
+
+		if (strcmp(key, "HID_ID") == 0) {
+			/**
+			 *        type vendor   product
+			 * HID_ID=0003:000005AC:00008242
+			 **/
+			int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
+			if (ret == 3) {
+				found_id = 1;
+			}
+		} else if (strcmp(key, "HID_NAME") == 0) {
+			/* The caller has to free the product name */
+			*product_name_utf8 = strdup(value);
+			found_name = 1;
+		} else if (strcmp(key, "HID_UNIQ") == 0) {
+			/* The caller has to free the serial number */
+			*serial_number_utf8 = strdup(value);
+			found_serial = 1;
+		}
+
+next_line:
+		line = strtok_r(NULL, "\n", &saveptr);
+	}
+
+	free(tmp);
+	return (found_id && found_name && found_serial);
+}
+
+
+static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen)
 {
 	struct udev *udev;
-	struct udev_device *udev_dev, *parent;
+	struct udev_device *udev_dev, *parent, *hid_dev;
 	struct stat s;
 	int ret = -1;
-	
-	setlocale(LC_ALL,"");
 
 	/* Create the udev object */
 	udev = udev_new();
@@ -178,26 +259,80 @@
 	/* Open a udev device from the dev_t. 'c' means character device. */
 	udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
 	if (udev_dev) {
-		const char *str;
-		/* Find the parent USB Device */
-		parent = udev_device_get_parent_with_subsystem_devtype(
-		       udev_dev,
-		       "usb",
-		       "usb_device");
-		if (parent) {
-			str = udev_device_get_sysattr_value(parent, key);
-			if (str) {
-				/* Convert the string from UTF-8 to wchar_t */
-				ret = mbstowcs(string, str, maxlen);
-				goto end;
-			}
+		hid_dev = udev_device_get_parent_with_subsystem_devtype(
+			udev_dev,
+			"hid",
+			NULL);
+		if (hid_dev) {
+			unsigned short dev_vid;
+			unsigned short dev_pid;
+			char *serial_number_utf8 = NULL;
+			char *product_name_utf8 = NULL;
+			int bus_type;
+
+			ret = parse_uevent_info(
+			           udev_device_get_sysattr_value(hid_dev, "uevent"),
+			           &bus_type,
+			           &dev_vid,
+			           &dev_pid,
+			           &serial_number_utf8,
+			           &product_name_utf8);
+
+			if (bus_type == BUS_BLUETOOTH) {
+				switch (key) {
+					case DEVICE_STRING_MANUFACTURER:
+						wcsncpy(string, L"", maxlen);
+						ret = 0;
+						break;
+					case DEVICE_STRING_PRODUCT:
+						ret = mbstowcs(string, product_name_utf8, maxlen);
+						ret = (ret == (size_t)-1)? -1: 0;
+						break;
+					case DEVICE_STRING_SERIAL:
+						ret = mbstowcs(string, serial_number_utf8, maxlen);
+						ret = (ret == (size_t)-1)? -1: 0;
+						break;
+					default:
+						ret = -1;
+						break;
+				}
+			}
+			else {
+				/* This is a USB device. Find its parent USB Device node. */
+				parent = udev_device_get_parent_with_subsystem_devtype(
+					   udev_dev,
+					   "usb",
+					   "usb_device");
+				if (parent) {
+					const char *str;
+					const char *key_str = NULL;
+
+					if (key >= 0 && key < DEVICE_STRING_COUNT) {
+						key_str = device_string_names[key];
+					} else {
+						ret = -1;
+						goto end;
+					}
+
+					str = udev_device_get_sysattr_value(parent, key_str);
+					if (str) {
+						/* Convert the string from UTF-8 to wchar_t */
+						ret = mbstowcs(string, str, maxlen);
+						ret = (ret == (size_t)-1)? -1: 0;
+						goto end;
+					}
+				}
+			}
+
+			free(serial_number_utf8);
+			free(product_name_utf8);
 		}
 	}
 
 end:
 	udev_device_unref(udev_dev);
-	// parent doesn't need to be (and can't be) unref'd.
-	// I'm not sure why, but it'll throw double-free() errors.
+	// parent and hid_dev don't need to be (and can't be) unref'd.
+	// I'm not sure why, but they'll throw double-free() errors.
 	udev_unref(udev);
 
 	return ret;
@@ -205,7 +340,13 @@
 
 int HID_API_EXPORT hid_init(void)
 {
-	/* Nothing to do for this in the Linux/hidraw implementation. */
+	const char *locale;
+
+	/* Set the locale if it's not set. */
+	locale = setlocale(LC_CTYPE, NULL);
+	if (!locale)
+		setlocale(LC_CTYPE, "");
+
 	return 0;
 }
 
@@ -215,6 +356,7 @@
 	return 0;
 }
 
+
 struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
 {
 	struct udev *udev;
@@ -223,8 +365,9 @@
 	
 	struct hid_device_info *root = NULL; // return object
 	struct hid_device_info *cur_dev = NULL;
-	
-	setlocale(LC_ALL,"");
+	struct hid_device_info *prev_dev = NULL; // previous device
+
+	hid_init();
 
 	/* Create the udev object */
 	udev = udev_new();
@@ -244,46 +387,57 @@
 		const char *sysfs_path;
 		const char *dev_path;
 		const char *str;
+		struct udev_device *raw_dev; // The device's hidraw udev node.
 		struct udev_device *hid_dev; // The device's HID udev node.
-		struct udev_device *dev; // The actual hardware device.
+		struct udev_device *usb_dev; // The device's USB udev node.
 		struct udev_device *intf_dev; // The device's interface (in the USB sense).
 		unsigned short dev_vid;
 		unsigned short dev_pid;
-		
+		char *serial_number_utf8 = NULL;
+		char *product_name_utf8 = NULL;
+		int bus_type;
+		int result;
+
 		/* Get the filename of the /sys entry for the device
 		   and create a udev_device object (dev) representing it */
 		sysfs_path = udev_list_entry_get_name(dev_list_entry);
-		hid_dev = udev_device_new_from_syspath(udev, sysfs_path);
-		dev_path = udev_device_get_devnode(hid_dev);
-		
-		/* The device pointed to by hid_dev contains information about
-		   the hidraw device. In order to get information about the
-		   USB device, get the parent device with the
-		   subsystem/devtype pair of "usb"/"usb_device". This will
-		   be several levels up the tree, but the function will find
-		   it.*/
-		dev = udev_device_get_parent_with_subsystem_devtype(
-		       hid_dev,
-		       "usb",
-		       "usb_device");
-		if (!dev) {
-			/* Unable to find parent usb device. */
-			goto next;
-		}
-
-		/* Get the VID/PID of the device */
-		str = udev_device_get_sysattr_value(dev,"idVendor");
-		dev_vid = (str)? strtol(str, NULL, 16): 0x0;
-		str = udev_device_get_sysattr_value(dev, "idProduct");
-		dev_pid = (str)? strtol(str, NULL, 16): 0x0;
+		raw_dev = udev_device_new_from_syspath(udev, sysfs_path);
+		dev_path = udev_device_get_devnode(raw_dev);
+
+		hid_dev = udev_device_get_parent_with_subsystem_devtype(
+			raw_dev,
+			"hid",
+			NULL);
+
+		if (!hid_dev) {
+			/* Unable to find parent hid device. */
+			goto next;
+		}
+
+		result = parse_uevent_info(
+			udev_device_get_sysattr_value(hid_dev, "uevent"),
+			&bus_type,
+			&dev_vid,
+			&dev_pid,
+			&serial_number_utf8,
+			&product_name_utf8);
+
+		if (!result) {
+			/* parse_uevent_info() failed for at least one field. */
+			goto next;
+		}
+
+		if (bus_type != BUS_USB && bus_type != BUS_BLUETOOTH) {
+			/* We only know how to handle USB and BT devices. */
+			goto next;
+		}
 
 		/* Check the VID/PID against the arguments */
 		if ((vendor_id == 0x0 && product_id == 0x0) ||
 		    (vendor_id == dev_vid && product_id == dev_pid)) {
 			struct hid_device_info *tmp;
-			size_t len;
 
-		    	/* VID/PID match. Create the record. */
+			/* VID/PID match. Create the record. */
 			tmp = malloc(sizeof(struct hid_device_info));
 			if (cur_dev) {
 				cur_dev->next = tmp;
@@ -291,56 +445,96 @@
 			else {
 				root = tmp;
 			}
+			prev_dev = cur_dev;
 			cur_dev = tmp;
-			
+
 			/* Fill out the record */
 			cur_dev->next = NULL;
-			str = dev_path;
-			if (str) {
-				len = strlen(str);
-				cur_dev->path = calloc(len+1, sizeof(char));
-				strncpy(cur_dev->path, str, len+1);
-				cur_dev->path[len] = '\0';
-			}
-			else
-				cur_dev->path = NULL;
-			
-			/* Serial Number */
-			cur_dev->serial_number
-				= copy_udev_string(dev, "serial");
+			cur_dev->path = dev_path? strdup(dev_path): NULL;
 
-			/* Manufacturer and Product strings */
-			cur_dev->manufacturer_string
-				= copy_udev_string(dev, "manufacturer");
-			cur_dev->product_string
-				= copy_udev_string(dev, "product");
-			
 			/* VID/PID */
 			cur_dev->vendor_id = dev_vid;
 			cur_dev->product_id = dev_pid;
 
+			/* Serial Number */
+			cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
+
 			/* Release Number */
-			str = udev_device_get_sysattr_value(dev, "bcdDevice");
-			cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
-			
+			cur_dev->release_number = 0x0;
+
 			/* Interface Number */
 			cur_dev->interface_number = -1;
-			/* Get a handle to the interface's udev node. */
-			intf_dev = udev_device_get_parent_with_subsystem_devtype(
-				   hid_dev,
-				   "usb",
-				   "usb_interface");
-			if (intf_dev) {
-				str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
-				cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
+
+			switch (bus_type) {
+				case BUS_USB:
+					/* The device pointed to by raw_dev contains information about
+					   the hidraw device. In order to get information about the
+					   USB device, get the parent device with the
+					   subsystem/devtype pair of "usb"/"usb_device". This will
+					   be several levels up the tree, but the function will find
+					   it. */
+					usb_dev = udev_device_get_parent_with_subsystem_devtype(
+							raw_dev,
+							"usb",
+							"usb_device");
+
+					if (!usb_dev) {
+						/* Free this device */
+						free(cur_dev->serial_number);
+						free(cur_dev->path);
+						free(cur_dev);
+
+						/* Take it off the device list. */
+						if (prev_dev) {
+							prev_dev->next = NULL;
+							cur_dev = prev_dev;
+						}
+						else {
+							cur_dev = root = NULL;
+						}
+
+						goto next;
+					}
+
+					/* Manufacturer and Product strings */
+					cur_dev->manufacturer_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_MANUFACTURER]);
+					cur_dev->product_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_PRODUCT]);
+
+					/* Release Number */
+					str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
+					cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
+
+					/* Get a handle to the interface's udev node. */
+					intf_dev = udev_device_get_parent_with_subsystem_devtype(
+							raw_dev,
+							"usb",
+							"usb_interface");
+					if (intf_dev) {
+						str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
+						cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
+					}
+
+					break;
+
+				case BUS_BLUETOOTH:
+					/* Manufacturer and Product strings */
+					cur_dev->manufacturer_string = wcsdup(L"");
+					cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
+
+					break;
+
+				default:
+					/* Unknown device type - this should never happen, as we
+					 * check for USB and Bluetooth devices above */
+					break;
 			}
 		}
-		else
-			goto next;
 
 	next:
-		udev_device_unref(hid_dev);
-		/* dev and intf_dev don't need to be (and can't be)
+		free(serial_number_utf8);
+		free(product_name_utf8);
+		udev_device_unref(raw_dev);
+		/* hid_dev, usb_dev and intf_dev don't need to be (and can't be)
 		   unref()d.  It will cause a double-free() error.  I'm not
 		   sure why.  */
 	}
@@ -365,7 +559,7 @@
 	}
 }
 
-hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
 	struct hid_device_info *devs, *cur_dev;
 	const char *path_to_open = NULL;
@@ -404,6 +598,8 @@
 {
 	hid_device *dev = NULL;
 
+	hid_init();
+
 	dev = new_hid_device();
 
 	if (kernel_version == 0) {
@@ -570,17 +766,17 @@
 
 int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
 {
-	return get_device_string(dev, "manufacturer", string, maxlen);
+	return get_device_string(dev, DEVICE_STRING_MANUFACTURER, string, maxlen);
 }
 
 int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
 {
-	return get_device_string(dev, "product", string, maxlen);
+	return get_device_string(dev, DEVICE_STRING_PRODUCT, string, maxlen);
 }
 
 int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
 {
-	return get_device_string(dev, "serial", string, maxlen);
+	return get_device_string(dev, DEVICE_STRING_SERIAL, string, maxlen);
 }
 
 int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)

=== modified file 'mixxx/lib/hidapi/mac/hid.c'
--- mixxx/lib/hidapi-0.7.0/mac/hid.c	2012-01-28 09:23:48 +0000
+++ mixxx/lib/hidapi/mac/hid.c	2012-08-26 04:54:21 +0000
@@ -263,16 +263,25 @@
 
 static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
 {
-	CFStringRef str = IOHIDDeviceGetProperty(device, prop);
-
-	buf[0] = 0x0000;
+	CFStringRef str;
+	
+	if (!len)
+		return 0;
+
+	str = IOHIDDeviceGetProperty(device, prop);
+
+	buf[0] = 0;
 
 	if (str) {
+		len --;
+
+		CFIndex str_len = CFStringGetLength(str);
 		CFRange range;
 		range.location = 0;
-		range.length = len;
+		range.length = (str_len > len)? len: str_len;
 		CFIndex used_buf_len;
-		CFStringGetBytes(str,
+		CFIndex chars_copied;
+		chars_copied = CFStringGetBytes(str,
 			range,
 			kCFStringEncodingUTF32LE,
 			(char)'?',
@@ -280,26 +289,35 @@
 			(UInt8*)buf,
 			len,
 			&used_buf_len);
-		buf[len-1] = 0x00000000;
-		return used_buf_len;
+
+		buf[chars_copied] = 0;
+		return 0;
 	}
 	else
-		return 0;
+		return -1;
 		
 }
 
 static int get_string_property_utf8(IOHIDDeviceRef device, CFStringRef prop, char *buf, size_t len)
 {
-	CFStringRef str = IOHIDDeviceGetProperty(device, prop);
-
-	buf[0] = 0x0000;
+	CFStringRef str;
+	if (!len)
+		return 0;
+
+	str = IOHIDDeviceGetProperty(device, prop);
+
+	buf[0] = 0;
 
 	if (str) {
+		len--;
+
+		CFIndex str_len = CFStringGetLength(str);
 		CFRange range;
 		range.location = 0;
-		range.length = len;
+		range.length = (str_len > len)? len: str_len;
 		CFIndex used_buf_len;
-		CFStringGetBytes(str,
+		CFIndex chars_copied;
+		chars_copied = CFStringGetBytes(str,
 			range,
 			kCFStringEncodingUTF8,
 			(char)'?',
@@ -307,12 +325,12 @@
 			(UInt8*)buf,
 			len,
 			&used_buf_len);
-		buf[len-1] = 0x00000000;
+
+		buf[chars_copied] = 0;
 		return used_buf_len;
 	}
 	else
 		return 0;
-		
 }
 
 
@@ -369,26 +387,32 @@
 	return res+1;
 }
 
+/* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */
 static int init_hid_manager(void)
 {
 	IOReturn res;
 	
 	/* Initialize all the HID Manager Objects */
 	hid_mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
-	IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
-	IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
-	res = IOHIDManagerOpen(hid_mgr, kIOHIDOptionsTypeNone);
-	return (res == kIOReturnSuccess)? 0: -1;
+	if (hid_mgr) {
+		IOHIDManagerSetDeviceMatching(hid_mgr, NULL);
+		IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+		return 0;
+	}
+	
+	return -1;
 }
 
+/* Initialize the IOHIDManager if necessary. This is the public function, and
+   it is safe to call this function repeatedly. Return 0 for success and -1
+   for failure. */
 int HID_API_EXPORT hid_init(void)
 {
 	if (!hid_mgr) {
-		if (init_hid_manager() < 0) {
-			hid_exit();
-			return -1;
-		}
+		return init_hid_manager();
 	}
+
+	/* Already initialized. */
 	return 0;
 }
 
@@ -404,6 +428,13 @@
 	return 0;
 }
 
+static void process_pending_events() {
+	SInt32 res;
+	do {
+		res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);
+	} while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);
+}
+
 struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
 {
 	struct hid_device_info *root = NULL; // return object
@@ -411,11 +442,13 @@
 	CFIndex num_devices;
 	int i;
 	
-	setlocale(LC_ALL,"");
+	/* Set up the HID Manager if it hasn't been done */
+	if (hid_init() < 0)
+		return NULL;
+	
+	/* give the IOHIDManager a chance to update itself */
+	process_pending_events();
 
-	/* Set up the HID Manager if it hasn't been done */
-	hid_init();
-	
 	/* Get a list of the Devices */
 	CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
 
@@ -508,7 +541,7 @@
 	}
 }
 
-hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
 	/* This function is identical to the Linux version. Platform independent. */
 	struct hid_device_info *devs, *cur_dev;
@@ -676,13 +709,6 @@
 	pthread_cond_broadcast(&dev->condition);
 	pthread_mutex_unlock(&dev->mutex);
 
-	/* Close the OS handle to the device, but only if it's not
-	   been unplugged. If it's been unplugged, then calling
-	   IOHIDDeviceClose() will crash. */
-	if (!dev->disconnected) {
-		IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeNone);
-	}
-	
 	/* Wait here until hid_close() is called and makes it past
 	   the call to CFRunLoopWakeUp(). This thread still needs to
 	   be valid when that function is called on the other thread. */
@@ -700,7 +726,11 @@
 	dev = new_hid_device();
 
 	/* Set up the HID Manager if it hasn't been done */
-	hid_init();
+	if (hid_init() < 0)
+		return NULL;
+
+	/* give the IOHIDManager a chance to update itself */
+	process_pending_events();
 
 	CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
 	
@@ -720,6 +750,7 @@
 				char str[32];
 
 				free(device_array);
+				CFRetain(os_dev);
 				CFRelease(device_set);
 				dev->device_handle = os_dev;
 				
@@ -1012,6 +1043,7 @@
 		return_data(dev, NULL, 0);
 	}
 	pthread_mutex_unlock(&dev->mutex);
+	CFRelease(dev->device_handle);
 
 	free_hid_device(dev);
 }
@@ -1096,8 +1128,6 @@
 	IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
 	CFSetGetValues(device_set, (const void **) device_array);
 	
-	setlocale(LC_ALL, "");
-	
 	for (i = 0; i < num_devices; i++) {
 		IOHIDDeviceRef dev = device_array[i];
 		printf("Device: %p\n", dev);

=== modified file 'mixxx/lib/hidapi/windows/Makefile.mingw'
--- mixxx/lib/hidapi-0.7.0/windows/Makefile.mingw	2012-01-28 09:23:48 +0000
+++ mixxx/lib/hidapi/windows/Makefile.mingw	2012-08-26 04:54:21 +0000
@@ -6,7 +6,7 @@
 # 2010-06-01
 ###########################################
 
-all: hidtest
+all: hidtest libhidapi.dll
 
 CC=gcc
 CXX=g++
@@ -15,11 +15,14 @@
 OBJS=$(COBJS) $(CPPOBJS)
 CFLAGS=-I../hidapi -g -c
 LIBS= -lsetupapi
-
+DLL_LDFLAGS = -mwindows -lsetupapi
 
 hidtest: $(OBJS)
 	g++ -g $^ $(LIBS) -o hidtest
 
+libhidapi.dll: $(OBJS)
+	$(CC) -g $^ $(DLL_LDFLAGS) -o libhidapi.dll
+
 $(COBJS): %.o: %.c
 	$(CC) $(CFLAGS) $< -o $@
 

=== modified file 'mixxx/lib/hidapi/windows/hid.c'
--- mixxx/lib/hidapi-0.7.0/windows/hid.c	2012-01-28 09:23:48 +0000
+++ mixxx/lib/hidapi/windows/hid.c	2012-08-26 04:54:21 +0000
@@ -93,8 +93,8 @@
 		USHORT Reserved[17];
 		USHORT fields_not_used_by_hidapi[10];
 	} HIDP_CAPS, *PHIDP_CAPS;
-	typedef char* HIDP_PREPARSED_DATA;
-	#define HIDP_STATUS_SUCCESS 0x0
+	typedef void* PHIDP_PREPARSED_DATA;
+	#define HIDP_STATUS_SUCCESS 0x110000
 
 	typedef BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib);
 	typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len);
@@ -103,9 +103,9 @@
 	typedef BOOLEAN (__stdcall *HidD_SetFeature_)(HANDLE handle, PVOID data, ULONG length);
 	typedef BOOLEAN (__stdcall *HidD_GetFeature_)(HANDLE handle, PVOID data, ULONG length);
 	typedef BOOLEAN (__stdcall *HidD_GetIndexedString_)(HANDLE handle, ULONG string_index, PVOID buffer, ULONG buffer_len);
-	typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, HIDP_PREPARSED_DATA **preparsed_data);
-	typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(HIDP_PREPARSED_DATA *preparsed_data);
-	typedef BOOLEAN (__stdcall *HidP_GetCaps_)(HIDP_PREPARSED_DATA *preparsed_data, HIDP_CAPS *caps);
+	typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, PHIDP_PREPARSED_DATA *preparsed_data);
+	typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(PHIDP_PREPARSED_DATA preparsed_data);
+	typedef NTSTATUS (__stdcall *HidP_GetCaps_)(PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps);
 
 	static HidD_GetAttributes_ HidD_GetAttributes;
 	static HidD_GetSerialNumberString_ HidD_GetSerialNumberString;
@@ -125,6 +125,7 @@
 struct hid_device_ {
 		HANDLE device_handle;
 		BOOL blocking;
+		USHORT output_report_length;
 		size_t input_report_length;
 		void *last_error_str;
 		DWORD last_error_num;
@@ -138,6 +139,7 @@
 	hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
 	dev->device_handle = INVALID_HANDLE_VALUE;
 	dev->blocking = TRUE;
+	dev->output_report_length = 0;
 	dev->input_report_length = 0;
 	dev->last_error_str = NULL;
 	dev->last_error_num = 0;
@@ -205,34 +207,22 @@
 }
 #endif
 
-static HANDLE open_device(const char *path)
+static HANDLE open_device(const char *path, BOOL enumerate)
 {
 	HANDLE handle;
+	DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ);
+	DWORD share_mode = (enumerate)?
+	                      FILE_SHARE_READ|FILE_SHARE_WRITE:
+	                      FILE_SHARE_READ;
 
-	/* First, try to open with sharing mode turned off. This will make it so
-	   that a HID device can only be opened once. This is to be consistent
-	   with the behavior on the other platforms. */
 	handle = CreateFileA(path,
-		GENERIC_WRITE |GENERIC_READ,
-		0, /*share mode*/
+		desired_access,
+		share_mode,
 		NULL,
 		OPEN_EXISTING,
 		FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_NORMAL,
 		0);
 
-	if (handle == INVALID_HANDLE_VALUE) {
-		/* Couldn't open the device. Some devices must be opened
-		   with sharing enabled (even though they are only opened once),
-		   so try it here. */
-		handle = CreateFileA(path,
-			GENERIC_WRITE |GENERIC_READ,
-			FILE_SHARE_READ|FILE_SHARE_WRITE, /*share mode*/
-			NULL,
-			OPEN_EXISTING,
-			FILE_FLAG_OVERLAPPED,//FILE_ATTRIBUTE_NORMAL,
-			0);
-	}
-
 	return handle;
 }
 
@@ -274,11 +264,13 @@
 	SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL;
 	HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
 	int device_index = 0;
+	int i;
 
 	if (hid_init() < 0)
 		return NULL;
 
 	// Initialize the Windows objects.
+	memset(&devinfo_data, 0x0, sizeof(devinfo_data));
 	devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
 	device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
@@ -334,10 +326,35 @@
 			goto cont;
 		}
 
+		// Make sure this device is of Setup Class "HIDClass" and has a
+		// driver bound to it.
+		for (i = 0; ; i++) {
+			char driver_name[256];
+
+			// Populate devinfo_data. This function will return failure
+			// when there are no more interfaces left.
+			res = SetupDiEnumDeviceInfo(device_info_set, i, &devinfo_data);
+			if (!res)
+				goto cont;
+
+			res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
+			               SPDRP_CLASS, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
+			if (!res)
+				goto cont;
+
+			if (strcmp(driver_name, "HIDClass") == 0) {
+				// See if there's a driver bound.
+				res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,
+				           SPDRP_DRIVER, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);
+				if (res)
+					break;
+			}
+		}
+
 		//wprintf(L"HandleName: %s\n", device_interface_detail_data->DevicePath);
 
 		// Open a handle to the device
-		write_handle = open_device(device_interface_detail_data->DevicePath);
+		write_handle = open_device(device_interface_detail_data->DevicePath, TRUE);
 
 		// Check validity of write_handle.
 		if (write_handle == INVALID_HANDLE_VALUE) {
@@ -360,7 +377,7 @@
 			#define WSTR_LEN 512
 			const char *str;
 			struct hid_device_info *tmp;
-			HIDP_PREPARSED_DATA *pp_data = NULL;
+			PHIDP_PREPARSED_DATA pp_data = NULL;
 			HIDP_CAPS caps;
 			BOOLEAN res;
 			NTSTATUS nt_res;
@@ -482,7 +499,7 @@
 }
 
 
-HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
 	// TODO: Merge this functions with the Linux version. This function should be platform independent.
 	struct hid_device_info *devs, *cur_dev;
@@ -522,7 +539,7 @@
 {
 	hid_device *dev;
 	HIDP_CAPS caps;
-	HIDP_PREPARSED_DATA *pp_data = NULL;
+	PHIDP_PREPARSED_DATA pp_data = NULL;
 	BOOLEAN res;
 	NTSTATUS nt_res;
 
@@ -533,7 +550,7 @@
 	dev = new_hid_device();
 
 	// Open a handle to the device
-	dev->device_handle = open_device(path);
+	dev->device_handle = open_device(path, FALSE);
 
 	// Check validity of write_handle.
 	if (dev->device_handle == INVALID_HANDLE_VALUE) {
@@ -553,6 +570,7 @@
 		register_error(dev, "HidP_GetCaps");	
 		goto err_pp_data;
 	}
+	dev->output_report_length = caps.OutputReportByteLength;
 	dev->input_report_length = caps.InputReportByteLength;
 	HidD_FreePreparsedData(pp_data);
 
@@ -574,15 +592,35 @@
 	BOOL res;
 
 	OVERLAPPED ol;
+	unsigned char *buf;
 	memset(&ol, 0, sizeof(ol));
 
-	res = WriteFile(dev->device_handle, data, length, NULL, &ol);
+	/* Make sure the right number of bytes are passed to WriteFile. Windows
+	   expects the number of bytes which are in the _longest_ report (plus
+	   one for the report number) bytes even if the data is a report
+	   which is shorter than that. Windows gives us this value in
+	   caps.OutputReportByteLength. If a user passes in fewer bytes than this,
+	   create a temporary buffer which is the proper size. */
+	if (length >= dev->output_report_length) {
+		/* The user passed the right number of bytes. Use the buffer as-is. */
+		buf = (unsigned char *) data;
+	} else {
+		/* Create a temporary buffer and copy the user's data
+		   into it, padding the rest with zeros. */
+		buf = (unsigned char *) malloc(dev->output_report_length);
+		memcpy(buf, data, length);
+		memset(buf + length, 0, dev->output_report_length - length);
+		length = dev->output_report_length;
+	}
+
+	res = WriteFile(dev->device_handle, buf, length, NULL, &ol);
 	
 	if (!res) {
 		if (GetLastError() != ERROR_IO_PENDING) {
 			// WriteFile() failed. Return error.
 			register_error(dev, "WriteFile");
-			return -1;
+			bytes_written = -1;
+			goto end_of_function;
 		}
 	}
 
@@ -592,9 +630,14 @@
 	if (!res) {
 		// The Write operation failed.
 		register_error(dev, "WriteFile");
-		return -1;
+		bytes_written = -1;
+		goto end_of_function;
 	}
 
+end_of_function:
+	if (buf != data)
+		free(buf);
+
 	return bytes_written;
 }
 
@@ -610,6 +653,7 @@
 	if (!dev->read_pending) {
 		// Start an Overlapped I/O read.
 		dev->read_pending = TRUE;
+		memset(dev->read_buf, 0, dev->input_report_length);
 		ResetEvent(ev);
 		res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol);
 		
@@ -648,12 +692,15 @@
 			   number (0x0) on the beginning of the report anyway. To make this
 			   work like the other platforms, and to make it work more like the
 			   HID spec, we'll skip over this byte. */
+			size_t copy_len;
 			bytes_read--;
-			memcpy(data, dev->read_buf+1, length);
+			copy_len = length > bytes_read ? bytes_read : length;
+			memcpy(data, dev->read_buf+1, copy_len);
 		}
 		else {
 			/* Copy the whole buffer, report number and all. */
-			memcpy(data, dev->read_buf, length);
+			size_t copy_len = length > bytes_read ? bytes_read : length;
+			memcpy(data, dev->read_buf, copy_len);
 		}
 	}
 	

=== modified file 'mixxx/src/controllers/controller.h'
--- mixxx/src/controllers/controller.h	2012-08-09 04:18:27 +0000
+++ mixxx/src/controllers/controller.h	2012-08-26 04:54:21 +0000
@@ -46,6 +46,12 @@
     inline bool isOpen() const {
         return m_bIsOpen;
     }
+    inline bool isConnected() const {
+        return m_bIsConnected;
+    }
+    inline void setConnected(bool connected) {
+        m_bIsConnected = connected;
+    }
     inline bool isOutputDevice() const {
         return m_bIsOutputDevice;
     }
@@ -160,6 +166,8 @@
     bool m_bIsInputDevice;
     // Indicates whether or not the device has been opened for input/output.
     bool m_bIsOpen;
+    // Indicates whether or not the device is connected (hotplug).
+    bool m_bIsConnected;
     // Specifies whether or not we should dump incoming data to the console at
     // runtime. This is useful for end-user debugging and script-writing.
     bool m_bDebug;

=== modified file 'mixxx/src/controllers/controllermanager.cpp'
--- mixxx/src/controllers/controllermanager.cpp	2012-07-08 23:27:47 +0000
+++ mixxx/src/controllers/controllermanager.cpp	2012-08-26 04:54:21 +0000
@@ -31,6 +31,7 @@
 #else
 const int kPollIntervalMillis = 1;
 #endif
+const int kUpdateIntervalMillis = 3000;
 
 QString firstAvailableFilename(QSet<QString>& filenames,
                                const QString originalFilename) {
@@ -48,6 +49,26 @@
     return a->getName() < b->getName();
 }
 
+bool controllersModified(QList<Controller*> c_old, QList<Controller*> c_new) {
+    if (c_old.length()!=c_new.length()) 
+        return true;
+     
+    foreach (Controller *a, c_old) {
+        bool device_found = false;
+        if (!a->isConnected())
+            return true;
+        foreach (Controller *b, c_new) {
+            if (a->getName()==b->getName()) {
+                device_found=true;
+                break;
+            }
+        }
+        if (!device_found) 
+            return true;
+    }
+    return false;
+}
+
 ControllerManager::ControllerManager(ConfigObject<ConfigValue> * pConfig) :
         QObject(),
         m_pConfig(pConfig),
@@ -85,6 +106,10 @@
     connect(&m_pollTimer, SIGNAL(timeout()),
             this, SLOT(pollDevices()));
 
+    m_updateTimer.setInterval(kUpdateIntervalMillis);
+    connect(&m_updateTimer, SIGNAL(timeout()),
+            this, SLOT(slotUpdateDevices()));
+
     m_pThread = new QThread;
     m_pThread->setObjectName("Controller");
 
@@ -95,8 +120,8 @@
     // audio directly, like when scratching
     m_pThread->start(QThread::HighPriority);
 
-    connect(this, SIGNAL(requestSetUpDevices()),
-            this, SLOT(slotSetUpDevices()));
+    connect(this, SIGNAL(requestUpdateDevices()),
+            this, SLOT(slotUpdateDevices()));
     connect(this, SIGNAL(requestShutdown()),
             this, SLOT(slotShutdown()));
     connect(this, SIGNAL(requestSave(bool)),
@@ -133,12 +158,15 @@
     m_pThread->quit();
 }
 
-void ControllerManager::updateControllerList() {
+bool ControllerManager::updateControllerList() {
     QMutexLocker locker(&m_mutex);
     if (m_enumerators.isEmpty()) {
-        qWarning() << "updateControllerList called but no enumerators have been added!";
-        return;
+        // qWarning() << 
+        //      "updateControllerList called but no enumerators have been added!";
+        return false;
     }
+
+    
     QList<ControllerEnumerator*> enumerators = m_enumerators;
     locker.unlock();
 
@@ -147,12 +175,15 @@
         newDeviceList.append(pEnumerator->queryDevices());
     }
 
+    // List of controllers did not change
+    if (!controllersModified(m_controllers,newDeviceList)) {
+        return false;
+    }
+ 
     locker.relock();
-    if (newDeviceList != m_controllers) {
-        m_controllers = newDeviceList;
-        locker.unlock();
-        emit(devicesChanged());
-    }
+    m_controllers = newDeviceList;
+    locker.unlock();
+    return true;
 }
 
 QList<Controller*> ControllerManager::getControllers() const {
@@ -161,7 +192,7 @@
 }
 
 QList<Controller*> ControllerManager::getControllerList(bool bOutputDevices, bool bInputDevices) {
-    qDebug() << "ControllerManager::getControllerList";
+    // qDebug() << "ControllerManager::getControllerList";
 
     QMutexLocker locker(&m_mutex);
     QList<Controller*> controllers = m_controllers;
@@ -180,51 +211,79 @@
     return filteredDeviceList;
 }
 
-int ControllerManager::slotSetUpDevices() {
-    qDebug() << "ControllerManager: Setting up devices";
-
-    updateControllerList();
-    QList<Controller*> deviceList = getControllerList(false, true);
-
-    QSet<QString> filenames;
+void ControllerManager::startDeviceUpdateTimer() {
+    if (!m_updateTimer.isActive()) {
+        m_updateTimer.start();
+        qDebug() << "Controller update polling started.";
+    }
+}
+
+int ControllerManager::slotUpdateDevices() {
+
+    bool devices_modified;
     int error = 0;
-
+    int device_error = 0;
+    startDeviceUpdateTimer();
+
+    devices_modified = updateControllerList();
+    if (!devices_modified) {
+        return 0;
+    }
+
+    QList<Controller*> deviceList = getControllerList(false, true);
     foreach (Controller* pController, deviceList) {
-        QString name = pController->getName();
-
-        if (pController->isOpen()) {
-            pController->close();
-        }
-
-        // The filename for this device name.
-        const QString ofilename = presetFilenameFromName(name);
-        // The first unique filename for this device (appends numbers at the end
-        // if we have already seen a controller by this name on this run of
-        // Mixxx.
-        QString filename = firstAvailableFilename(filenames, ofilename);
-
-        if (!loadPreset(pController, filename, true)) {
-            // TODO(XXX) : auto load midi preset here.
-            continue;
-        }
-
-        if (m_pConfig->getValueString(ConfigKey("[Controller]", ofilename)) != "1") {
-            continue;
-        }
-
-        qDebug() << "Opening controller:" << name;
-
-        int value = pController->open();
-        if (value != 0) {
-            qWarning() << "There was a problem opening" << name;
-            if (error == 0) {
-                error = value;
-            }
-            continue;
-        }
-        pController->applyPreset(m_pConfig->getResourcePath());
-    }
-
+        if (!pController->isConnected()) {
+            devices_modified = true;
+            continue;
+        }
+
+        device_error = setupController(pController);
+        if (device_error!=-1)
+            error = device_error;
+    }
+    if (devices_modified)
+        emit(devicesChanged());
+
+    maybeStartOrStopPolling();
+    return error;
+}
+
+int ControllerManager::setupController(Controller *pController) {
+    QSet<QString> filenames;
+    int error = -1;
+
+    // Don't reopen existing devices 
+    if (!pController || pController->isOpen())
+        return error;
+
+    QString name = pController->getName();
+    // The filename for this device name.
+    const QString ofilename = presetFilenameFromName(name);
+
+    // Controller not enabled
+    if (m_pConfig->getValueString(ConfigKey("[Controller]", ofilename)) != "1") {
+        return error;
+    }
+
+    // The first unique filename for this device (appends numbers at the end
+    // if we have already seen a controller by this name on this run of
+    // Mixxx.
+    QString filename = firstAvailableFilename(filenames, ofilename);
+    if (!loadPreset(pController, filename, true)) {
+        // TODO(XXX) : auto load midi preset here.
+        return error;
+    }
+
+    qDebug() << "Opening controller:" << name;
+    int value = pController->open();
+    if (value != 0) {
+        qWarning() << "There was a problem opening" << name;
+        if (error == 0) {
+            error = value;
+        }
+        return error;
+    }
+    pController->applyPreset(m_pConfig->getResourcePath());
     maybeStartOrStopPolling();
     return error;
 }
@@ -266,7 +325,9 @@
     do {
         eventsProcessed = false;
         foreach (Controller* pDevice, m_controllers) {
-            if (pDevice->isOpen() && pDevice->isPolling()) {
+            if (!pDevice->isConnected()) {
+                eventsProcessed = false || eventsProcessed; 
+            } else if (pDevice->isOpen() && pDevice->isPolling()) {
                 eventsProcessed = pDevice->poll() || eventsProcessed;
             }
         }

=== modified file 'mixxx/src/controllers/controllermanager.h'
--- mixxx/src/controllers/controllermanager.h	2012-05-31 06:38:14 +0000
+++ mixxx/src/controllers/controllermanager.h	2012-08-26 04:54:21 +0000
@@ -20,6 +20,8 @@
 // Function to sort controllers by name
 bool controllerCompare(Controller *a,Controller *b);
 
+bool controllersModified(QList<Controller*> c_old, QList<Controller*> c_new);
+
 /** Manages enumeration/operation/deletion of hardware controllers. */
 class ControllerManager : public QObject {
     Q_OBJECT
@@ -33,18 +35,18 @@
     PresetInfoEnumerator* getPresetInfoManager();
 
     // Prevent other parts of Mixxx from having to manually connect to our slots
-    void setUpDevices() { emit(requestSetUpDevices()); };
+    void updateDevices() { emit(requestUpdateDevices()); };
     void savePresets(bool onlyActive=false) { emit(requestSave(onlyActive)); };
     void shutdown() { emit(requestShutdown()); };
 
   signals:
     void devicesChanged();
-    void requestSetUpDevices();
+    void requestUpdateDevices();
     void requestShutdown();
     void requestSave(bool onlyActive);
 
   public slots:
-    void updateControllerList();
+    bool updateControllerList();
 
     void openController(Controller* pController);
     void closeController(Controller* pController);
@@ -56,7 +58,7 @@
     // Open whatever controllers are selected in the preferences. This currently
     // only runs on start-up but maybe should instead be signaled by the
     // preferences dialog on apply, and only open/close changed devices
-    int slotSetUpDevices();
+    int slotUpdateDevices();
     void slotShutdown();
     bool loadPreset(Controller* pController,
                     ControllerPresetPointer preset);
@@ -67,6 +69,8 @@
     void startPolling();
     void stopPolling();
     void maybeStartOrStopPolling();
+    void startDeviceUpdateTimer();
+    int setupController(Controller *pController);
 
     static QString presetFilenameFromName(QString name) {
         return name.replace(" ", "_");
@@ -76,6 +80,7 @@
     ConfigObject<ConfigValue> *m_pConfig;
     ControllerLearningEventFilter* m_pControllerLearningEventFilter;
     QTimer m_pollTimer;
+    QTimer m_updateTimer;
     mutable QMutex m_mutex;
     QList<ControllerEnumerator*> m_enumerators;
     QList<Controller*> m_controllers;

=== modified file 'mixxx/src/controllers/hid/hidcontroller.cpp'
--- mixxx/src/controllers/hid/hidcontroller.cpp	2012-08-09 04:18:27 +0000
+++ mixxx/src/controllers/hid/hidcontroller.cpp	2012-08-26 04:54:21 +0000
@@ -115,6 +115,8 @@
     setInputDevice(true);
     setOutputDevice(true);
     m_pReader = NULL;
+    // Device is marked connected (but not open) when initialized
+    setConnected(true);
 }
 
 HidController::~HidController() {
@@ -325,15 +327,23 @@
     // Append the Report ID to the beginning of data[] per the API..
     data.prepend(reportID);
 
+    if (!isConnected())
+        return;
+
     int result = hid_write(m_pHidDevice, (unsigned char*)data.constData(), data.size());
     if (result == -1) {
+        const wchar_t* error = hid_error(m_pHidDevice);
+        if (error==NULL) {
+            setConnected(false);
+            return;
+        }
         if (debugging()) {
             qWarning() << "Unable to send data to" << getName()
                        << "serial #" << hid_serial << ":"
-                       << QString::fromWCharArray(hid_error(m_pHidDevice));
+                       << QString::fromWCharArray(error);
         } else {
             qWarning() << "Unable to send data to" << getName() << ":"
-                       << QString::fromWCharArray(hid_error(m_pHidDevice));
+                       << QString::fromWCharArray(error);
         }
     } else if (debugging()) {
         qDebug() << result << "bytes sent to" << getName()

=== modified file 'mixxx/src/controllers/hid/hidcontroller.h'
--- mixxx/src/controllers/hid/hidcontroller.h	2012-08-09 04:18:27 +0000
+++ mixxx/src/controllers/hid/hidcontroller.h	2012-08-26 04:54:21 +0000
@@ -68,6 +68,8 @@
     virtual bool matchProductInfo(QHash <QString,QString >);
     virtual void guessDeviceCategory();
 
+    const inline QString getPath() { return QString((const char *)hid_path);}
+
   protected:
     Q_INVOKABLE void send(QList<int> data, unsigned int length, unsigned int reportID = 0);
 

=== modified file 'mixxx/src/controllers/hid/hidenumerator.cpp'
--- mixxx/src/controllers/hid/hidenumerator.cpp	2012-05-27 03:32:05 +0000
+++ mixxx/src/controllers/hid/hidenumerator.cpp	2012-08-26 04:54:21 +0000
@@ -61,24 +61,37 @@
     return false;
 }
 
+bool HidEnumerator::isDeviceLoaded(struct hid_device_info *device) {
+    HidController* m_dev;
+    QString device_path, match_path;
+    if (!device)
+        return false;
+    device_path = QString(device->path);
+
+    foreach (Controller *c_ptr, m_devices) {
+        m_dev = (HidController*) c_ptr;
+        match_path = m_dev->getPath();
+        if (device_path==match_path) {
+            return true;
+        }
+    }
+    return false;
+}
+
 QList<Controller*> HidEnumerator::queryDevices() {
-    qDebug() << "Scanning HID devices:";
+    // qeebug() << "Scanning HID devices:";
 
     struct hid_device_info *devs, *cur_dev;
     devs = hid_enumerate(0x0, 0x0);
 
     for (cur_dev = devs; cur_dev; cur_dev = cur_dev->next) {
         if (isDeviceBlacklisted(cur_dev)) {
-            // OS/X and windows use usage_page/usage not interface_number
-            qDebug() << "Blacklisting"
-                     << cur_dev->manufacturer_string
-                     << cur_dev->product_string
-                     << QString("r%1").arg(cur_dev->release_number)
-                     << "S/N" << cur_dev->serial_number
-                     << (cur_dev->interface_number == -1 ? QString("Usage Page %1 Usage %2").arg(
-                         QString::number(cur_dev->usage_page),
-                         QString::number(cur_dev->usage)) :
-                         QString("Interface %1").arg(cur_dev->interface_number));
+            // Do not print blacklisted devices (would be printed
+            // each time hotplug devices are queried)
+            continue;
+        }
+
+        if (isDeviceLoaded(cur_dev)) {
             continue;
         }
 
@@ -101,6 +114,28 @@
         HidController* currentDevice = new HidController(*cur_dev);
         m_devices.push_back(currentDevice);
     }
+
+    // Check for removed / disconnected devices
+    foreach (Controller* c_ptr, m_devices) {
+        HidController* m_dev = (HidController *) c_ptr;
+        QString device_path, match_path;
+        bool device_found = false;
+
+        device_path = m_dev->getPath();
+        for (cur_dev = devs; cur_dev; cur_dev = cur_dev->next) {
+            match_path = QString(cur_dev->path);
+            if (device_path==match_path) {
+                device_found = true;
+                break;
+            }
+        }
+        if (!device_found) {
+            qDebug() << "Disconnected HID device " << m_dev->getPath();
+            m_dev->setConnected(false);
+            m_devices.removeOne(m_dev);
+        }
+    }
+
     hid_free_enumeration(devs);
 
     return m_devices;

=== modified file 'mixxx/src/controllers/hid/hidenumerator.h'
--- mixxx/src/controllers/hid/hidenumerator.h	2012-04-23 03:42:12 +0000
+++ mixxx/src/controllers/hid/hidenumerator.h	2012-08-26 04:54:21 +0000
@@ -19,6 +19,7 @@
 
   private:
     QList<Controller*> m_devices;
+    bool isDeviceLoaded(struct hid_device_info *device);
 };
 
 #endif

=== modified file 'mixxx/src/controllers/midi/portmidicontroller.cpp'
--- mixxx/src/controllers/midi/portmidicontroller.cpp	2012-06-14 17:42:13 +0000
+++ mixxx/src/controllers/midi/portmidicontroller.cpp	2012-08-26 04:54:21 +0000
@@ -31,6 +31,10 @@
     if (m_pOutputDeviceInfo) {
         setOutputDevice(m_pOutputDeviceInfo->output);
     }
+
+    // PortMIDI devices are always connected, until we implement hotplug
+    // for portMIDI
+    setConnected(true);
 }
 
 PortMidiController::~PortMidiController() {
@@ -221,6 +225,9 @@
 }
 
 void PortMidiController::send(QByteArray data) {
+    if (!isConnected()) {
+        return;
+    }
     if (m_pOutputStream) {
         PmError err = Pm_WriteSysEx(m_pOutputStream, 0, (unsigned char*)data.constData());
         if (err != pmNoError) {

=== modified file 'mixxx/src/controllers/midi/portmidienumerator.cpp'
--- mixxx/src/controllers/midi/portmidienumerator.cpp	2012-04-24 05:42:04 +0000
+++ mixxx/src/controllers/midi/portmidienumerator.cpp	2012-08-26 04:54:21 +0000
@@ -28,6 +28,11 @@
   * To help simplify a lot of code, we're going to aggregate these two streams into a single full-duplex device.
   */
 QList<Controller*> PortMidiEnumerator::queryDevices() {
+    // Portmidi does not support hotplug: if any devices were already 
+    // loaded, return current list
+    if (m_devices.length()>0)
+        return m_devices;
+
     qDebug() << "Scanning PortMIDI devices:";
 
     int iNumDevices = Pm_CountDevices();
@@ -37,8 +42,6 @@
         delete dev_it.next();
     }
 
-    m_devices.clear();
-
     const PmDeviceInfo *deviceInfo, *inputDeviceInfo, *outputDeviceInfo;
     int inputDevIndex, outputDevIndex;
     QMap<int,QString> unassignedOutputDevices;

=== modified file 'mixxx/src/mixxx.cpp'
--- mixxx/src/mixxx.cpp	2012-07-22 09:31:52 +0000
+++ mixxx/src/mixxx.cpp	2012-08-26 04:54:21 +0000
@@ -506,7 +506,7 @@
 
     // Wait until all other ControlObjects are set up
     //  before initializing controllers
-    m_pControllerManager->setUpDevices();
+    m_pControllerManager->updateDevices();
 }
 
 MixxxApp::~MixxxApp()