Merge lp:~mixxxdevelopers/mixxx/features_controllerAbstraction into lp:~mixxxdevelopers/mixxx/trunk

[RJ Skerry-Ryan]

Abstracts the controller subsystem to support multiple protocols. MIDI subsystem partially rewritten, directories, classes and threads reorganized. Adds full HID controller support. Removes MIDI mapping GUI for now.

[William Good (bkgood)]

Maybe I missed the discussion on this but while I agree that the GUI mapping support totally sucks do we really want to remove it without replacing it?

[RJ Skerry-Ryan (rryan)]

For 1.11 I think we're just going to remove it. The general reasoning is
that since we haven't really had anyone complaining about how hard it is to
use like about 2 years of it being there.. the only conclusion must be that
close to nobody uses it.

Code-wise it was very complicated too and really screwed up the MIDI
mapping implementation since they were deeply intertwined. I'd rather nuke
it in 1.11 and come up with a really nice one for 1.12 or create an
external mapping program.

On Sun, Mar 18, 2012 at 9:26 PM, Bill Good <email address hidden> wrote:

> Maybe I missed the discussion on this but while I agree that the GUI
> mapping support totally sucks do we really want to remove it without
> replacing it?
> --
>
> https://code.launchpad.net/~mixxxdevelopers/mixxx/features_controllerAbstraction/+merge/98121
> You proposed lp:~mixxxdevelopers/mixxx/features_controllerAbstraction for
> merging.
>

[Sean M. Pappalardo (pegasus-renegadetech)]

We could add back the MIDI mapping wizard if you like, since there's already a message signal and a learning flag in place in MidiController. MC just needs a slot to get data from the wizard, then the wizard would need to be adjusted to work with these signals/slots. I'll check into this further.

[RJ Skerry-Ryan (rryan)]

Hey Sean,

I realize you haven't put the finishing touches on the branch yet. I'm sorry in advance because this review is going to seem a little brutal but I'm convinced that we need to do things right. The main problem I saw with the MIDI subsystem in 1.10 is that everything was totally commingled. This made it impossible to write unit tests for a given class because we had swiss-army-knife classes that did everything. We need to move away from this.

I want to get you this feedback as soon as possible, so here it is. I may have more comments to share later.

* Please make sure to remove commented code referring to non-existing stuff (e.g. all commented lines you left in build/depends.py that refer to old files that don't exist anymore)

* Make sure to delete "res/controllers/Stanton SCS.1m VUMETERS ONLY.xml"

* Please delete src/controllers/OLDmidi soon because it makes reviewing your branch hard (the diff is gigantic).

* In defs_controllers.h, make helper functions instead of these macros. (DEFAULT_DEVICE_PRESET, DEFAULT_MIDI_DEVICE_PRESET in particular. Ideally PRESETS_PATH and LPRESETS_PATH as well).

* Please add "virtual" to every destructor declaration.

* It's good that the old MidiMapping class died because it was a mutable-shared-state-logic-monster. That said, storing the mappings in the controller is almost as bad.
   - Let's pull all mappings out into a Mapping/MidiMapping class. This class should be plain-old-data, not a QObject (e.g. no signals/slots) and no methods except the minimum needed for Controller to look up the script files, MidiController to look up a mapped control in receive() and to look up output mappings where it creates the MidiOutputHandlers.

* Take all serialization/deserialization code and put it into a MappingParser/MidiMappingParser helper class which creates a Mapping/MidiMapping class from a given path.

* Delete loadPreset / savePreset / buildDomElement methods in Controller/MidiController .. replace them with a setMapping() command. A controller that doesn't have a mapping yet can be considered invalid.

* Controllers shouldn't be concerned with saving a preset. Instead that should be the controller preferences dialog or the ControllerManager's job to deserialize the mapping and call Controller::setMapping().

* Need to remove all methods that deal with a char*/length data buffer e.g. Controller::send, Controller::receivePointer. Instead we should be using QByteArray for everything.

* Remove length argument from Controller::sendBa since a QByteArray knows its own length. Also, rename sendBa to send(). Also make the argument a const QByteArray.

* I'd prefer we get rid of the Controller::send(QList<int>) method and instead require people to use QByteArrays but I'm not sure if this is easy from scripts so maybe we can let it be. Please change the implementation of Controller::send(QList<int>, int) to build a QByteArray and call send(QByteArray).

* In ControllerManager, please remove the m_pPMEnumerator, m_pHSSEnumerator, m_pHIDEnumerator, and m_pOSCEnumerator declarations. Instead use a QList of ControllerEnumerator* objects. Add an "addControllerEnumerator()" method to ControllerManager, an...

review: Needs Fixing

[Sean M. Pappalardo (pegasus-renegadetech)]

> * Please make sure to remove commented code referring to non-existing stuff
> * Make sure to delete "res/controllers/Stanton SCS.1m VUMETERS ONLY.xml"
> * Please delete src/controllers/OLDmidi soon because it makes reviewing your

These are among the reasons why I didn't propose a merge yet, silly. :)

> * In defs_controllers.h, make helper functions instead of these macros.

What benefit would that give? The macros are straightforward and fast.

> * Please add "virtual" to every destructor declaration.

As a matter of course? What will that do? I only do it to destructors that will be reimplemented.

> shared-state-logic-monster. That said, storing the mappings in the controller
> is almost as bad.

I do this because I view a Controller as a device, with all properties particular to that device (e.g. a mapping) contained in the one object. Then due to the time-sensitive nature of MIDI processing, I imagine local object data is faster to access.

> * Take all serialization/deserialization code and put it into a
> MappingParser/MidiMappingParser helper class which creates a
> Mapping/MidiMapping class from a given path.

That sounds like overkill. If we do in fact make a MidiMapping class, shouldn't the same class that holds the data be responsible for all operations on that data?

> * Need to remove all methods that deal with a char*/length data buffer e.g.
> Controller::send, Controller::receivePointer. Instead we should be using
> QByteArray for everything.

Not all of them can be removed without duplicating code or complicating the classes, since the device APIs send and expect data this way. If we try, know that interfacing raw bytes between JS and C++ is a very delicate issue. I've had numerous problems with bytes getting mangled in the past.
Plus I imagine primitive data types to be slightly faster. Here again, what would be the benefit of switching to QByteArrays?

> * I'd prefer we get rid of the Controller::send(QList<int>) method and instead
> require people to use QByteArrays

We can't. This is how QtScript passes data byte arrays to C++.

> * In ControllerManager, please remove the m_pPMEnumerator, m_pHSSEnumerator,
> m_pHIDEnumerator, and m_pOSCEnumerator declarations.

Thanks for the suggested methods. This was bothering me too but I couldn't think of a neat way to fix it.

> * midi-mappings-scripts.js You're changing the names of a lot of common script
> stuff. Won't this break MIDI-scripts in the wild?

Yes, but the only things that will be incompatible are MidiButtonState and MidiLedState. A README telling to search-n-replace will fix them right up. I left backwards-compatible calls for everything else.

[Owen Williams (ywwg)]

We should think long and hard before breaking people's scripts, even if a simple search-and-replace will fix it. I'd prefer to leave scripts stable and only limit breakage to major releases (2.0, etc). I'm not super-familiar with this branch, but is this breakage necessary?

[RJ Skerry-Ryan (rryan)]

On Mon, Mar 19, 2012 at 4:14 PM, Sean M. Pappalardo
<email address hidden>wrote:

> > * Please make sure to remove commented code referring to non-existing
> stuff
> > * Make sure to delete "res/controllers/Stanton SCS.1m VUMETERS ONLY.xml"
> > * Please delete src/controllers/OLDmidi soon because it makes reviewing
> your
>
> These are among the reasons why I didn't propose a merge yet, silly. :)
>
> > * In defs_controllers.h, make helper functions instead of these macros.
>
> What benefit would that give? The macros are straightforward and fast.
>

Macros should only be used for constants. They're no faster than an inline
function. These particular macros refer to member variables of a class and
have logic in them. This obscures the logic within the class they are used
in because it is hidden behind what looks like a constant. If they have
member variables then they're specific to a class so why not make them a
private inline helper function of that class?

>
> > * Please add "virtual" to every destructor declaration.
>
> As a matter of course? What will that do? I only do it to destructors that
> will be reimplemented.
>
>
It's just something that every class should have. It should be as automatic
as making your member variables private. Some day in the future someone
will subclass your class -- guaranteed. Be nice to them -- it might even be
your future self. :)

> > shared-state-logic-monster. That said, storing the mappings in the
> controller
> > is almost as bad.
>
> I do this because I view a Controller as a device, with all properties
> particular to that device (e.g. a mapping) contained in the one object.
> Then due to the time-sensitive nature of MIDI processing, I imagine local
> object data is faster to access.
>
>
It's fine for the controller to have a mapping. That mapping should be
encapsulated into one class so you can pass them around and vary the
implementation of the mapping independent of the class that consumes the
mapping (the Controller).

Accessing a member variable versus the member variable of another class is
possibly the difference in 1 or two assembly instructions -- if any
difference. If you care about this in the name of speed then I'm surprised
you use so many virtual functions (they are about 2x slower than a regular
function call). This sort of difference is totally meaningless from a Mixxx
performance perspective. We're talking picoseconds here!

Don't let tens or hundreds of assembly instructions get in the way of
writing good code. For the long-term health of the project it's worth it to
structure the project in small, bite-sized and testable classes. This is
extra work, I know.

> > * Take all serialization/deserialization code and put it into a
> > MappingParser/MidiMappingParser helper class which creates a
> > Mapping/MidiMapping class from a given path.
>
> That sounds like overkill. If we do in fact make a MidiMapping class,
> shouldn't the same class that holds the data be responsible for all
> operations on that data?
>

The mapping parsing / serializing code is long enough to warrant living in
its own utility class. It is long and obscures the purpose of whatever
class it lives in (origin...

[Sean M. Pappalardo (pegasus-renegadetech)]

> Macros should only be used for constants.

My bad, I forgot there were member variables in two of them. Don't know what I was thinking when I did that.

> difference. If you care about this in the name of speed then I'm surprised
> you use so many virtual functions (they are about 2x slower than a regular
> function call).

:O I had no idea! Is that 2x slowdown a matter of picoseconds too?

> The mapping parsing / serializing code is long enough to warrant living in
> its own utility class. It is long and obscures the purpose of whatever
> class it lives in (originally MidiMapping, now *Controller).

What bothers me about separating it is that there is no generic ControllerMapping class (at least not yet,) so MidiMappings are specific to MIDI controllers, so why not make them an integral part? I see your point though and will make the change.

> 1.10. Can we keep the ButtonState and LedState as they are for MIDI and
> mark them deprecated?

Actually, leaving them without the "Midi" prefix should be fine, since non-MIDI controllers will need to set the values differently anyway.

[Sean M. Pappalardo (pegasus-renegadetech)]

LOL, I removed the OLDmidi directory and the diff got bigger. (Not surprised.)

RJ, while I work on the rest, I need you to take a look at ControllerEngine::connectControl() and figure out why using COTs breaks automatic reactions. They work fine in trunk so I have no idea.

[Sean M. Pappalardo (pegasus-renegadetech)]

Hello again. Looking at your class-separation requests more closely now, I still have reservations:

> - Let's pull all mappings out into a Mapping/MidiMapping class. This class
> should be plain-old-data, not a QObject (e.g. no signals/slots) and no methods

I'm sorry, I can't see the benefit of doing that. It would just add complexity and make it harder for *Controller to be expanded in the future such as when the GUI signals it to add/delete/change mappings. (Besides, a preset is just two QLists. Specific *Controllers add two QHashes for mappings.)

> * Take all serialization/deserialization code and put it into a
> MappingParser/MidiMappingParser helper class

Here too, moving those functions to another class would add needless complexity because they have to access data that's specific to a Controller. I understand the desire to have classes not be too long, but don't let that get in the way of logical design. In this case, everything that's in *Controller is specific to that type of device. (Yes, that includes the parsing code, since it's specific to the mapping storage format, which is specific to the device type.) Trying to separate it across multiple classes would cause us to have shared-state logic monsters again and make it much more difficult to follow for those new to the code. Since it sounds like you're interested in visual separation, I have moved the functions that handle XML into separate .cpp files and have simply #included these in the main *Controller ones.

> * Controllers shouldn't be concerned with saving a preset. Instead that should
> be the controller preferences dialog or the ControllerManager's job

The ControllerManager _is_ in charge of saving presets. The Controllers just contain the code to do so, because it's specific to each Controller type (as stated above,) and the Manager isn't concerned with those details (or it would be micro-managing.)

In short, there's nothing else that can be factored out.

If your concerns are motivated by unit-testing issues, why can't we just write separate tests for different aspects of a class?

[RJ Skerry-Ryan (rryan)]

On Apr 7, 2012 7:38 AM, "Sean M. Pappalardo" <email address hidden> wrote:
>
> Hello again. Looking at your class-separation requests more closely now,
I still have reservations:
>
> > - Let's pull all mappings out into a Mapping/MidiMapping class. This
class
> > should be plain-old-data, not a QObject (e.g. no signals/slots) and no
methods
>
> I'm sorry, I can't see the benefit of doing that. It would just add
complexity and make it harder for *Controller to be expanded in the future
such as when the GUI signals it to add/delete/change mappings. (Besides, a
preset is just two QLists. Specific *Controllers add two QHashes for
mappings.)

The benefit is encapsulation of the mapping implementation.

Add/delete/change of a mapping from the GUI is the reason the old midi
system is so terrible. The only way to load a mapping going forward will be
to call Controller::loadMapping(ControllerMapping).

>
> > * Take all serialization/deserialization code and put it into a
> > MappingParser/MidiMappingParser helper class
>
> Here too, moving those functions to another class would add needless
complexity because they have to access data that's specific to a
Controller. I understand the desire to have classes not be too long, but
don't let that get in the way of logical design. In this case, everything
that's in *Controller is specific to that type of device. (Yes, that
includes the parsing code, since it's specific to the mapping storage
format, which is specific to the device type.) Trying to separate it across
multiple classes would cause us to have shared-state logic monsters again
and make it much more difficult to follow for those new to the code. Since
it sounds like you're interested in visual separation, I have moved the
functions that handle XML into separate .cpp files and have simply
#included these in the main *Controller ones.

Putting this in a separate helper will allow us to test it and it will
simplify the ControllerMapping class considerably.

>
> > * Controllers shouldn't be concerned with saving a preset. Instead that
should
> > be the controller preferences dialog or the ControllerManager's job
>
> The ControllerManager _is_ in charge of saving presets. The Controllers
just contain the code to do so, because it's specific to each Controller
type (as stated above,) and the Manager isn't concerned with those details
(or it would be micro-managi

I think saving presets should be owned by the controller preferences dialog
and not even be part of the controller manager actually.

>
> In short, there's nothing else that can be factored out.
>
> If your concerns are motivated by unit-testing issues, why can't we just
write separate tests for different aspects of a class?

Well the general reason why this is is that you can't isolate the logic you
aim to test when it's all mixed together in one class.

I feel bad coming down hard but these issues are non-negotiable. In the
past I haven't held the MIDI subsystem to as high a standard as say the
engine but now that you are rewriting it I'd like to change that. "It
works" is not good enough for infrastructure code (which this is going to
be more than ever as we add more controller types) so...

[lp:~mixxxdevelopers/mixxx/features_controllerAbstraction]

2818. By Sean M. Pappalardo on 2012-04-09

Improvements to soft-takeover algorithm. It works really well now.

2819. By Sean M. Pappalardo on 2012-04-09

WIP: class-ifying the ControllerPresets and ControllerPresetFileHandlers. Currently broken, committing so RJ can take a look.

2820. By RJ Skerry-Ryan on 2012-04-09

* Add HidControllerPreset and HidControllerPresetFileHandler
  (necessary to keep ControllerPreset and ControllerPresetFileHandler
  abstract)

* Many fixes here and there to get things building.

* Add ControllerPresetVisitor, a visitor to get a Controller subclass
  the real type of the preset being loaded to it.

2821. By RJ Skerry-Ryan on 2012-04-09

Check for null handlers and presets.

2822. By RJ Skerry-Ryan on 2012-04-09

Minor errors, use QSet instead of QList for faster contains() checking.

2823. By RJ Skerry-Ryan on 2012-04-09

Constify a lot of stuff. Switch to having the controller be in charge of saving the preset because it knows the true type of the preset. If I didn't do this then I would have had to make ControllerPresetFileHandler a ControllerPresetVisitor as well, which isn't worth the extra lines of code. Fix some broken/unfinished code so the branch builds.

2824. By RJ Skerry-Ryan on 2012-04-10

Cleanup lint / style fixes in ControllerManager.

2825. By RJ Skerry-Ryan on 2012-04-10

error messages for preset mismatches.

2826. By RJ Skerry-Ryan on 2012-04-10

Tons of cleanups across the whole controllers/ hierarchy.

2827. By RJ Skerry-Ryan on 2012-04-10

Merging from lp:mixxx

2828. By Sean M. Pappalardo on 2012-04-10

- Removed all old MIDI code from dlgpreferences
- Fixed compilation with HID enabled after RJ's codefest.
- Replaced the dialog's ability to signal a controller preset load
- Removed the ConfigObject creation in ControllerEngine by passing it to Controller which passes the path the CE needs.
- ControllerManager and ControllerEngine now look for presets and script files in both res/ and the user directory
- Made MidiController::close() destroy the outputHandlers and set the *MidiControllers to call it within their close() functions.
- Added directory copy from midi/ to controllers/ in upgrade.cpp. Also improved the version number processing.

2829. By Sean M. Pappalardo on 2012-04-15

- Removed more old commented MIDI dialog code
- Cleaned up MixxxControl and added more properties. Perhaps it will become the center of Control 2.0 eventually?
- Converted the Controller subsystem to use MixxxControls instead of ConfigKeys. It's a bit cleaner.
- WIP: Trying to set up a DlgMappableController as a subclass of DlgController but it's showing the UI from the superclass. Help!
- WIP: DlgControllerLearning. I just comitted it so RJ can build to take a look at the above issue.

2830. By RJ Skerry-Ryan on 2012-04-15

Add IOKit and CoreFoundation frameworks. Fixes build on OS X

2831. By Sean M. Pappalardo on 2012-04-16

Fixed DlgMappableController selection and display. I can't get the table to expand to full window width so I'll need help with that.

2832. By Sean M. Pappalardo on 2012-04-18

- DlgMappableController successfully subclasses DlgController now
- Controller learning (MIDI) works now, though I can't test for sure since I won't be near a MIDI controller for weeks. NEED SOMEONE TO TEST PLEASE!!
- Made control descriptions easier to read, added count
- Sorted control descriptions by group
- Got number of decks and samplers from the global COs
- Disabled a bunch of not-yet-implemented stuff in the mapping pane.

2833. By Sean M. Pappalardo on 2012-04-20

Neatened up MIDI message display in learning dialog and prevented controls from affecting Mixxx during learning.

2834. By Sean M. Pappalardo on 2012-04-20

Made the Clear All button work.

2835. By RJ Skerry-Ryan on 2012-04-22

Get rid of fputs in upgrade.cpp

2836. By RJ Skerry-Ryan on 2012-04-23

Mass reformat tabs in SConscript to spaces. Remove all license blocks from src/controllers. Fix lint here and there. Remove unused code from MixxxControl.

2837. By RJ Skerry-Ryan on 2012-04-23

Rewrite SoftTakeover to use ControlObjects instead of MixxxControl.

2838. By RJ Skerry-Ryan on 2012-04-23

Move SoftTakeover to src/controllers/. Add more virtual destructors and fix style issues here and there.

2839. By RJ Skerry-Ryan on 2012-04-23

Remove more licenses. Fix more lint.

2840. By RJ Skerry-Ryan on 2012-04-23

Move HID code to src/controllers/hid.

2841. By RJ Skerry-Ryan on 2012-04-23

Move MixxxControl to src/controllers.

2842. By RJ Skerry-Ryan on 2012-04-23

Get rid of passing ControllerProcessor timerEvent()'s directly in favor of just calling a Controller::poll() method when the controller needs to poll (if it has polling enabled).

2843. By RJ Skerry-Ryan on 2012-04-24

Delete ControllerProcessor since it was just a wrapper around a QTimer essentially.

2844. By RJ Skerry-Ryan on 2012-04-24

Prevent changing visibility for a few methods. Mass re-format some class definitions to conform to mixxx indentation style.

2845. By RJ Skerry-Ryan on 2012-04-24

Comments, formatting.

2846. By RJ Skerry-Ryan on 2012-04-24

Remove redundant/unused code here and there.

2847. By RJ Skerry-Ryan on 2012-04-24

Parent DeviceChannelListener to its HSS1394Controller.

2848. By RJ Skerry-Ryan on 2012-04-24

* Remove polling declaration from ControllerEnumerator and put it in
  the Controllers themselves.

* Make all variables of Controller private and make sub-classes access
  via accessors.

2849. By RJ Skerry-Ryan on 2012-04-24

Remove dups option from MidiOutputHandler since it wasn't used anywhere.

2850. By RJ Skerry-Ryan on 2012-04-24

Add locking to protect m_controllers list in ControllerManager. Other misc cleanups.

2851. By RJ Skerry-Ryan on 2012-04-24

Make DlgPrefController vars private.

2852. By RJ Skerry-Ryan on 2012-04-24

Make DlgPrefController not call open() or close() on controllers anymore. Switch HidReader to use QAtomicInt instead of bool flag.

2853. By RJ Skerry-Ryan on 2012-04-24

Oops. Fix a bug I wrote in preset loading.

2854. By RJ Skerry-Ryan on 2012-04-24

Sean -- please take a look at the comment I left. Not sure what the desired behavior is here.

2855. By Sean M. Pappalardo on 2012-04-25

loadPreset takes a filename, not device name

2856. By RJ Skerry-Ryan on 2012-04-25

Clear pointer on delete.

2857. By Sean M. Pappalardo on 2012-04-25

Merging from trunk

Unmerged revisions

=== modified file 'mixxx/SConstruct'
--- mixxx/SConstruct	2011-11-08 07:39:27 +0000
+++ mixxx/SConstruct	2012-04-07 14:24:23 +0000
@@ -33,11 +33,11 @@
 toolchain = ARGUMENTS.get('toolchain', None)
 
 available_features = [features.HifiEq,
-                      features.MIDIScript,
                       features.Mad,
                       features.CoreAudio,
                       features.MediaFoundation,
                       features.HSS1394,
+                      features.HID,
                       features.VinylControl,
                       features.Shoutcast,
                       features.Profiling,

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2012-03-28 02:39:59 +0000
+++ mixxx/build/depends.py	2012-04-07 14:24:23 +0000
@@ -29,7 +29,7 @@
             raise Exception('Did not find PortMidi or its development headers.')
 
     def sources(self, build):
-        return ['midi/portmidienumerator.cpp', 'midi/midideviceportmidi.cpp']
+        return ['controllers/midi/portmidienumerator.cpp', 'controllers/midi/portmidicontroller.cpp']
 
 class OpenGL(Dependence):
 
@@ -158,6 +158,7 @@
             build.env.Append(LIBS = 'QtSql4')
             build.env.Append(LIBS = 'QtGui4')
             build.env.Append(LIBS = 'QtCore4')
+            build.env.Append(LIBS = 'QtScript4')
             build.env.Append(LIBS = 'QtWebKit4')
             build.env.Append(LIBS = 'QtNetwork4')
             build.env.Append(LIBS = 'QtOpenGL4')
@@ -168,6 +169,7 @@
                                       '$QTDIR/include/QtGui',
                                       '$QTDIR/include/QtXml',
                                       '$QTDIR/include/QtNetwork',
+                                      '$QTDIR/include/QtScript',
                                       '$QTDIR/include/QtSql',
                                       '$QTDIR/include/QtOpenGL',
                                       '$QTDIR/include/QtWebKit',
@@ -284,9 +286,9 @@
                    "dlgpreferences.cpp",
                    "dlgprefsound.cpp",
                    "dlgprefsounditem.cpp",
-                   "dlgprefmidibindings.cpp",
+                   "controllers/dlgprefcontroller.cpp",
+                   "controllers/dlgprefnocontrollers.cpp",
                    "dlgprefplaylist.cpp",
-                   "dlgprefnomidi.cpp",
                    "dlgprefcontrols.cpp",
                    "dlgprefbpm.cpp",
                    "dlgprefreplaygain.cpp",
@@ -295,7 +297,6 @@
                    "dlgabout.cpp",
                    "dlgprefeq.cpp",
                    "dlgprefcrossfader.cpp",
-                   "dlgmidilearning.cpp",
                    "dlgtrackinfo.cpp",
                    "dlgprepare.cpp",
                    "dlgautodj.cpp",
@@ -343,24 +344,23 @@
                    "analyserbpm.cpp",
                    "analyserwaveform.cpp",
 
-                   "midi/mididevice.cpp",
-                   "midi/mididevicemanager.cpp",
-                   "midi/midideviceenumerator.cpp",
-                   "midi/midimapping.cpp",
-                   "midi/midiinputmappingtablemodel.cpp",
-                   "midi/midioutputmappingtablemodel.cpp",
-                   "midi/midichanneldelegate.cpp",
-                   "midi/midistatusdelegate.cpp",
-                   "midi/midinodelegate.cpp",
-                   "midi/midioptiondelegate.cpp",
-                   "midi/midimessage.cpp",
-                   "midi/midiledhandler.cpp",
+                   "controllers/controller.cpp",
+                   "controllers/controllermanager.cpp",
+                   "controllers/controllerenumerator.cpp",
+                   "controllers/controllerengine.cpp",
+
+                   "controllers/qtscript-bytearray/bytearrayclass.cpp",
+                   "controllers/qtscript-bytearray/bytearrayprototype.cpp",
+
+                   # MIDI controllers
+                   "controllers/midi/midienumerator.cpp",
+                   "controllers/midi/midicontroller.cpp",
+                   "controllers/midi/midioutputhandler.cpp",
+
+                   "mixxxcontrol.cpp",
                    "softtakeover.cpp",
 
                    "main.cpp",
-                   "controlgroupdelegate.cpp",
-                   "controlvaluedelegate.cpp",
-                   "mixxxcontrol.cpp",
                    "mixxx.cpp",
                    "errordialoghandler.cpp",
                    "upgrade.cpp",
@@ -541,9 +541,11 @@
         # the code for the QT UI forms
         build.env.Uic4('dlgpreferencesdlg.ui')
         build.env.Uic4('dlgprefsounddlg.ui')
-        build.env.Uic4('dlgprefmidibindingsdlg.ui')
+        
+        build.env.Uic4('controllers/dlgprefcontrollerdlg.ui')
+        build.env.Uic4('controllers/dlgprefnocontrollersdlg.ui')
+        
         build.env.Uic4('dlgprefplaylistdlg.ui')
-        build.env.Uic4('dlgprefnomididlg.ui')
         build.env.Uic4('dlgprefcontrolsdlg.ui')
         build.env.Uic4('dlgprefeqdlg.ui')
         build.env.Uic4('dlgprefcrossfaderdlg.ui')
@@ -555,7 +557,6 @@
         build.env.Uic4('dlgprefnovinyldlg.ui')
         build.env.Uic4('dlgprefrecorddlg.ui')
         build.env.Uic4('dlgaboutdlg.ui')
-        build.env.Uic4('dlgmidilearning.ui')
         build.env.Uic4('dlgtrackinfo.ui')
         build.env.Uic4('dlgprepare.ui')
         build.env.Uic4('dlgautodj.ui')

=== modified file 'mixxx/build/features.py'
--- mixxx/build/features.py	2012-04-02 03:30:43 +0000
+++ mixxx/build/features.py	2012-04-07 14:24:23 +0000
@@ -44,11 +44,53 @@
         build.env.Append(CPPDEFINES = '__HSS1394__')
 
     def sources(self, build):
-        sources = SCons.Split("""midi/mididevicehss1394.cpp
-                            midi/hss1394enumerator.cpp
-                            """)
-        return sources
-
+        sources = SCons.Split("""controllers/midi/hss1394controller.cpp
+                            controllers/midi/hss1394enumerator.cpp
+                            """)
+        return sources
+
+class HID(Feature):
+    def description(self):
+        return "HID controller support"
+
+    def enabled(self, build):
+        build.flags['hid'] = util.get_flags(build.env, 'hid', 1)
+        if int(build.flags['hid']):
+            return True
+        return False
+
+    def add_options(self, build, vars):
+        vars.Add('hid', 'Set to 1 to enable HID controller support.', 1)
+
+    def configure(self, build, conf):
+        if not self.enabled(build):
+            return
+        if build.platform_is_linux and (not conf.CheckLib(['libusb-1.0', 'usb-1.0']) or not conf.CheckHeader('libusb-1.0/libusb.h')):
+            raise Exception('Did not find the libusb 1.0 development library or its header file, exiting!')
+            return
+        elif build.platform_is_windows:
+            if not conf.CheckLib(['hidapi', 'libhidapi']):
+                raise Exception('Did not find HIDAPI development library, exiting!')
+                return
+
+        build.env.Append(CPPDEFINES = '__HID__')
+
+    def sources(self, build):
+        build.env.Append(CPPPATH=['#lib/hidapi-0.7.0/hidapi'])
+        if build.platform_is_linux:
+            build.env.ParseConfig('pkg-config libusb-1.0 --silence-errors --cflags --libs')
+        sources = SCons.Split("""controllers/hidcontroller.cpp
+                            controllers/hidenumerator.cpp
+                            """)
+        if build.platform_is_windows:
+            # This doesn't work. You need to build it in MSVS like all the other dependencies
+            # sources.append("#lib/hidapi-0.7.0/windows/hid.c")
+            return sources
+        elif build.platform_is_osx:
+            sources.append("#lib/hidapi-0.7.0/mac/hid.c")
+        else:
+            sources.append("#lib/hidapi-0.7.0/linux/hid-libusb.c")
+        return sources
 
 class Mad(Feature):
     def description(self):
@@ -138,35 +180,6 @@
         build.env.Append(CPPDEFINES='__MEDIAFOUNDATION__')
         return
 
-class MIDIScript(Feature):
-    def description(self):
-        return "MIDI Scripting"
-
-    def enabled(self, build):
-        build.flags['midiscript'] = util.get_flags(build.env, 'midiscript', 0)
-        if int(build.flags['midiscript']):
-            return True
-        return False
-
-    def add_options(self, build, vars):
-        vars.Add('midiscript', 'Set to 1 to enable MIDI Scripting support.', 1)
-
-    def configure(self, build, conf):
-        if not self.enabled(build):
-            return
-        if build.platform_is_windows:
-            build.env.Append(LIBS = 'QtScript4')
-        elif build.platform_is_linux:
-                build.env.Append(LIBS = 'QtScript')
-        elif build.platform_is_osx:
-                # TODO(XXX) put in logic here to add a -framework QtScript
-                pass
-        build.env.Append(CPPPATH = '$QTDIR/include/QtScript')
-        build.env.Append(CPPDEFINES = '__MIDISCRIPT__')
-
-    def sources(self, build):
-        return ["midi/midiscriptengine.cpp"]
-
 class LADSPA(Feature):
 
     def description(self):

=== added directory 'mixxx/lib/hidapi-0.7.0'
=== added file 'mixxx/lib/hidapi-0.7.0/LICENSE-orig.txt'
--- mixxx/lib/hidapi-0.7.0/LICENSE-orig.txt	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/LICENSE-orig.txt	2012-04-07 14:24:23 +0000
@@ -0,0 +1,9 @@
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Copyright 2009, Alan Ott, Signal 11 Software.
+ All Rights Reserved.
+ 
+ This software may be used by anyone for any reason so
+ long as the copyright notice in the source files
+ remains intact.

=== added file 'mixxx/lib/hidapi-0.7.0/LICENSE.txt'
--- mixxx/lib/hidapi-0.7.0/LICENSE.txt	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/LICENSE.txt	2012-04-07 14:24:23 +0000
@@ -0,0 +1,13 @@
+HIDAPI can be used under one of three licenses.
+
+1. The GNU Public License, version 3.0, in LICENSE-gpl3.txt
+2. A BSD-Style License, in LICENSE-bsd.txt.
+3. The more liberal original HIDAPI license. LICENSE-orig.txt
+
+The license chosen is at the discretion of the user of HIDAPI. For example:
+1. An author of GPL software would likely use HIDAPI under the terms of the
+GPL.
+
+2. An author of commercial closed-source software would likely use HIDAPI
+under the terms of the BSD-style license or the original HIDAPI license.
+

=== added directory 'mixxx/lib/hidapi-0.7.0/hidapi'
=== added file 'mixxx/lib/hidapi-0.7.0/hidapi/hidapi.h'
--- mixxx/lib/hidapi-0.7.0/hidapi/hidapi.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/hidapi/hidapi.h	2012-04-07 14:24:23 +0000
@@ -0,0 +1,383 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include <wchar.h>
+
+#ifdef _WIN32
+      #define HID_API_EXPORT __declspec(dllexport)
+      #define HID_API_CALL
+#else
+      #define HID_API_EXPORT /**< API export macro */
+      #define HID_API_CALL /**< API call macro */
+#endif
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+		struct hid_device_;
+		typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+		/** hidapi info structure */
+		struct hid_device_info {
+			/** Platform-specific device path */
+			char *path;
+			/** Device Vendor ID */
+			unsigned short vendor_id;
+			/** Device Product ID */
+			unsigned short product_id;
+			/** Serial Number */
+			wchar_t *serial_number;
+			/** Device Release Number in binary-coded decimal,
+			    also known as Device Version Number */
+			unsigned short release_number;
+			/** Manufacturer String */
+			wchar_t *manufacturer_string;
+			/** Product string */
+			wchar_t *product_string;
+			/** Usage Page for this Device/Interface
+			    (Windows/Mac only). */
+			unsigned short usage_page;
+			/** Usage for this Device/Interface
+			    (Windows/Mac only).*/
+			unsigned short usage;
+			/** The USB interface which this logical device
+			    represents. Valid on both Linux implementations
+			    in all cases, and valid on the Windows implementation
+			    only if the device contains more than one interface. */
+			int interface_number;
+
+			/** Pointer to the next device */
+			struct hid_device_info *next;
+		};
+
+
+		/** @brief Initialize the HIDAPI library.
+
+			This function initializes the HIDAPI library. Calling it is not
+			strictly necessary, as it will be called automatically by
+			hid_enumerate() and any of the hid_open_*() functions if it is
+			needed.  This function should be called at the beginning of
+			execution however, if there is a chance of HIDAPI handles
+			being opened by different threads simultaneously.
+			
+			@ingroup API
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+		/** @brief Finalize the HIDAPI library.
+
+			This function frees all of the static data associated with
+			HIDAPI. It should be called at the end of execution to avoid
+			memory leaks.
+
+			@ingroup API
+
+		    @returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+		/** @brief Enumerate the HID Devices.
+
+			This function returns a linked list of all the HID devices
+			attached to the system which match vendor_id and product_id.
+			If @p vendor_id and @p product_id are both set to 0, then
+			all HID devices will be returned.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the types of device
+				to open.
+			@param product_id The Product ID (PID) of the types of
+				device to open.
+
+		    @returns
+		    	This function returns a pointer to a linked list of type
+		    	struct #hid_device, containing information about the HID devices
+		    	attached to the system, or NULL in the case of failure. Free
+		    	this linked list by calling hid_free_enumeration().
+		*/
+		struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+		/** @brief Free an enumeration Linked List
+
+		    This function frees a linked list created by hid_enumerate().
+
+			@ingroup API
+		    @param devs Pointer to a list of struct_device returned from
+		    	      hid_enumerate().
+		*/
+		void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
+
+		/** @brief Open a HID device using a Vendor ID (VID), Product ID
+			(PID) and optionally a serial number.
+
+			If @p serial_number is NULL, the first device with the
+			specified VID and PID is opened.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the device to open.
+			@param product_id The Product ID (PID) of the device to open.
+			@param serial_number The Serial Number of the device to open
+				               (Optionally NULL).
+
+			@returns
+				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);
+
+		/** @brief Open a HID device by its path name.
+
+			The path name be determined by calling hid_enumerate(), or a
+			platform-specific path name can be used (eg: /dev/hidraw0 on
+			Linux).
+
+			@ingroup API
+		    @param path The path name of the device to open
+
+			@returns
+				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_path(const char *path);
+
+		/** @brief Write an Output report to a HID device.
+
+			The first byte of @p data[] must contain the Report ID. For
+			devices which only support a single report, this must be set
+			to 0x0. The remaining bytes contain the report data. Since
+			the Report ID is mandatory, calls to hid_write() will always
+			contain one more byte than the report contains. For example,
+			if a hid report is 16 bytes long, 17 bytes must be passed to
+			hid_write(), the Report ID (or 0x0, for devices with a
+			single report), followed by the report data (16 bytes). In
+			this example, the length passed in would be 17.
+
+			hid_write() will send the data on the first OUT endpoint, if
+			one exists. If it does not, it will send the data through
+			the Control Endpoint (Endpoint 0).
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length);
+
+		/** @brief Read an Input report from a HID device with timeout.
+
+			Input reports are returned
+			to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+			@param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
+
+		/** @brief Read an Input report from a HID device.
+
+			Input reports are returned
+		    to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length);
+
+		/** @brief Set the device handle to be non-blocking.
+
+			In non-blocking mode calls to hid_read() will return
+			immediately with a value of 0 if there is no data to be
+			read. In blocking mode, hid_read() will wait (block) until
+			there is data to read before returning.
+
+			Nonblocking can be turned on and off at any time.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param nonblock enable or not the nonblocking reads
+			 - 1 to enable nonblocking
+			 - 0 to disable nonblocking.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock);
+
+		/** @brief Send a Feature report to the device.
+
+			Feature reports are sent over the Control endpoint as a
+			Set_Report transfer.  The first byte of @p data[] must
+			contain the Report ID. For devices which only support a
+			single report, this must be set to 0x0. The remaining bytes
+			contain the report data. Since the Report ID is mandatory,
+			calls to hid_send_feature_report() will always contain one
+			more byte than the report contains. For example, if a hid
+			report is 16 bytes long, 17 bytes must be passed to
+			hid_send_feature_report(): the Report ID (or 0x0, for
+			devices which do not use numbered reports), followed by the
+			report data (16 bytes). In this example, the length passed
+			in would be 17.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send, including
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length);
+
+		/** @brief Get a feature report from a HID device.
+
+			Make sure to set the first byte of @p data[] to the Report
+			ID of the report to be read.  Make sure to allow space for
+			this extra byte in @p data[].
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param data A buffer to put the read data into, including
+				the Report ID. Set the first byte of @p data[] to the
+				Report ID of the report to be read.
+			@param length The number of bytes to read, including an
+				extra byte for the report ID. The buffer can be longer
+				than the actual report.
+
+			@returns
+				This function returns the number of bytes read and
+				-1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length);
+
+		/** @brief Close a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+		*/
+		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device);
+
+		/** @brief Get The Manufacturer String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Product String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Serial Number String from a HID device.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string from a HID device, based on its string index.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+			@param string_index The index of the string to get.
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string describing the last error which occurred.
+
+			@ingroup API
+			@param device A device handle returned from hid_open().
+
+			@returns
+				This function returns a string containing the last error
+				which occurred or NULL if none has occurred.
+		*/
+		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

=== added directory 'mixxx/lib/hidapi-0.7.0/linux'
=== added file 'mixxx/lib/hidapi-0.7.0/linux/.gitignore'
--- mixxx/lib/hidapi-0.7.0/linux/.gitignore	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/linux/.gitignore	2012-04-07 14:24:23 +0000
@@ -0,0 +1,13 @@
+Debug
+Release
+*.exp
+*.ilk
+*.lib
+*.suo
+*.vcproj.*
+*.ncb
+*.suo
+*.dll
+*.pdb
+*.o
+hidtest
\ No newline at end of file

=== added file 'mixxx/lib/hidapi-0.7.0/linux/Makefile'
--- mixxx/lib/hidapi-0.7.0/linux/Makefile	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/linux/Makefile	2012-04-07 14:24:23 +0000
@@ -0,0 +1,36 @@
+###########################################
+# Simple Makefile for HIDAPI test program
+#
+# Alan Ott
+# Signal 11 Software
+# 2010-06-01
+###########################################
+
+all: hidtest
+
+CC       ?= gcc
+CFLAGS   ?= -Wall -g
+
+CXX      ?= g++
+CXXFLAGS ?= -Wall -g
+
+COBJS     = hid-libusb.o
+CPPOBJS   = ../hidtest/hidtest.o
+OBJS      = $(COBJS) $(CPPOBJS)
+LIBS      = `pkg-config libusb-1.0 libudev --libs`
+INCLUDES ?= -I../hidapi `pkg-config libusb-1.0 --cflags`
+
+
+hidtest: $(OBJS)
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) $^ $(LIBS) -o hidtest
+
+$(COBJS): %.o: %.c
+	$(CC) $(CFLAGS) -c $(INCLUDES) $< -o $@
+
+$(CPPOBJS): %.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $(INCLUDES) $< -o $@
+
+clean:
+	rm -f $(OBJS) hidtest
+
+.PHONY: clean

=== added file 'mixxx/lib/hidapi-0.7.0/linux/README.txt'
--- mixxx/lib/hidapi-0.7.0/linux/README.txt	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/linux/README.txt	2012-04-07 14:24:23 +0000
@@ -0,0 +1,63 @@
+
+There are two implementations of HIDAPI for Linux. One (hid.c) uses the
+Linux hidraw driver, and the other (hid-libusb.c) uses libusb. Which one you
+use depends on your application. Complete functionality of the hidraw
+version depends on patches to the Linux kernel which are not currently in
+the mainline. These patches have to do with sending and receiving feature
+reports. The libusb implementation uses libusb to talk directly to the
+device, bypassing any Linux HID driver. The disadvantage of the libusb
+version is that it will only work with USB devices, while the hidraw
+implementation will work with Bluetooth devices as well.
+
+To use HIDAPI, simply drop either hid.c or hid-libusb.c into your
+application and build using the build parameters in the Makefile.
+
+By default, on Linux, the Makefile in this directory is configured to use
+the libusb implementation. To switch to the hidraw implementation, simply
+change hid-libusb.c to hid.c in the Makefile.
+
+
+Libusb Implementation notes
+----------------------------
+For the libusb implementation, libusb-1.0 must be installed. Libusb 1.0 is
+different than the legacy libusb 0.1 which is installed on many systems.  To
+install libusb-1.0 on Ubuntu and other Debian-based systems, run:
+	sudo apt-get install libusb-1.0-0-dev
+
+
+Hidraw Implementation notes
+----------------------------
+For the hidraw implementation, libudev headers and libraries are required to
+build hidapi programs.  To install libudev libraries on Ubuntu,
+and other Debian-based systems, run:
+	sudo apt-get install libudev-dev
+
+On Redhat-based systems, run the following as root:
+	yum install libudev-devel
+
+Unfortunately, the hidraw driver, which the linux version of hidapi is based
+on, contains bugs in kernel versions < 2.6.36, which the client application
+should be aware of.
+
+Bugs (hidraw implementation only):
+-----------------------------------
+On Kernel versions < 2.6.34, if your device uses numbered reports, an extra
+byte will be returned at the beginning of all reports returned from read()
+for hidraw devices. This is worked around in the libary. No action should be
+necessary in the client library.
+
+On Kernel versions < 2.6.35, reports will only be sent using a Set_Report
+transfer on the CONTROL endpoint. No data will ever be sent on an Interrupt
+Out endpoint if one exists. This is fixed in 2.6.35. In 2.6.35, OUTPUT
+reports will be sent to the device on the first INTERRUPT OUT endpoint if it
+exists; If it does not exist, OUTPUT reports will be sent on the CONTROL
+endpoint.
+
+On Kernel versions < 2.6.36, add an extra byte containing the report number
+to sent reports if numbered reports are used, and the device does not
+contain an INTERRPUT OUT endpoint for OUTPUT transfers.  For example, if
+your device uses numbered reports and wants to send {0x2 0xff 0xff 0xff} to
+the device (0x2 is the report number), you must send {0x2 0x2 0xff 0xff
+0xff}. If your device has the optional Interrupt OUT endpoint, this does not
+apply (but really on 2.6.35 only, because 2.6.34 won't use the interrupt
+out endpoint).

=== added file 'mixxx/lib/hidapi-0.7.0/linux/hid-libusb.c'
--- mixxx/lib/hidapi-0.7.0/linux/hid-libusb.c	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/linux/hid-libusb.c	2012-04-07 14:24:23 +0000
@@ -0,0 +1,1386 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2010
+ Libusb Version - 8/13/2010
+
+ Copyright 2009, All Rights Reserved.
+ 
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+#define _GNU_SOURCE // needed for wcsdup() before glibc 2.10
+
+/* C */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <locale.h>
+#include <errno.h>
+
+/* Unix */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <wchar.h>
+
+/* GNU / LibUSB */
+#include "libusb.h"
+#include "iconv.h"
+
+#include "hidapi.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DEBUG_PRINTF
+#define LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#define LOG(...) do {} while (0)
+#endif
+
+
+/* Uncomment to enable the retrieval of Usage and Usage Page in
+hid_enumerate(). Warning, 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
+instead to differentiate between interfaces on a composite HID device. */
+/*#define INVASIVE_GET_USAGE*/
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+	uint8_t *data;
+	size_t len;
+	struct input_report *next;
+};
+
+
+struct hid_device_ {
+	/* Handle to the actual device. */
+	libusb_device_handle *device_handle;
+	
+	/* Endpoint information */
+	int input_endpoint;
+	int output_endpoint;
+	int input_ep_max_packet_size;
+
+	/* The interface number of the HID */	
+	int interface;
+	
+	/* Indexes of Strings */
+	int manufacturer_index;
+	int product_index;
+	int serial_index;
+	
+	/* Whether blocking reads are used */
+	int blocking; /* boolean */
+	
+	/* Read thread objects */
+	pthread_t thread;
+	pthread_mutex_t mutex; /* Protects input_reports */
+	pthread_cond_t condition;
+	pthread_barrier_t barrier; /* Ensures correct startup sequence */
+	int shutdown_thread;
+	struct libusb_transfer *transfer;
+
+	/* List of received input reports. */
+	struct input_report *input_reports;
+};
+
+static int initialized = 0;
+
+uint16_t get_usb_code_for_current_locale(void);
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+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);
+	pthread_barrier_init(&dev->barrier, NULL, 2);
+	
+	return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+	/* Clean up the thread objects */
+	pthread_barrier_destroy(&dev->barrier);
+	pthread_cond_destroy(&dev->condition);
+	pthread_mutex_destroy(&dev->mutex);
+
+	/* Free the device itself */
+	free(dev);
+}
+
+#if 0
+//TODO: Implement this funciton on Linux.
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+#ifdef INVASIVE_GET_USAGE
+/* Get bytes from a HID Report Descriptor.
+   Only call with a num_bytes of 0, 1, 2, or 4. */
+static uint32_t get_bytes(uint8_t *rpt, size_t len, size_t num_bytes, size_t cur)
+{
+	/* Return if there aren't enough bytes. */
+	if (cur + num_bytes >= len)
+		return 0;
+
+	if (num_bytes == 0)
+		return 0;
+	else if (num_bytes == 1) {
+		return rpt[cur+1];
+	}
+	else if (num_bytes == 2) {
+		return (rpt[cur+2] * 256 + rpt[cur+1]);
+	}
+	else if (num_bytes == 4) {
+		return (rpt[cur+4] * 0x01000000 +
+		        rpt[cur+3] * 0x00010000 +
+		        rpt[cur+2] * 0x00000100 +
+		        rpt[cur+1] * 0x00000001);
+	}
+	else
+		return 0;
+}
+
+/* Retrieves the device's Usage Page and Usage from the report
+   descriptor. The algorithm is simple, as it just returns the first
+   Usage and Usage Page that it finds in the descriptor.
+   The return value is 0 on success and -1 on failure. */
+static int get_usage(uint8_t *report_descriptor, size_t size,
+                     unsigned short *usage_page, unsigned short *usage)
+{
+	int i = 0;
+	int size_code;
+	int data_len, key_size;
+	int usage_found = 0, usage_page_found = 0;
+	
+	while (i < size) {
+		int key = report_descriptor[i];
+		int key_cmd = key & 0xfc;
+
+		//printf("key: %02hhx\n", key);
+		
+		if ((key & 0xf0) == 0xf0) {
+			/* This is a Long Item. The next byte contains the
+			   length of the data section (value) for this key.
+			   See the HID specification, version 1.11, section
+			   6.2.2.3, titled "Long Items." */
+			if (i+1 < size)
+				data_len = report_descriptor[i+1];
+			else
+				data_len = 0; /* malformed report */
+			key_size = 3;
+		}
+		else {
+			/* This is a Short Item. The bottom two bits of the
+			   key contain the size code for the data section
+			   (value) for this key.  Refer to the HID
+			   specification, version 1.11, section 6.2.2.2,
+			   titled "Short Items." */
+			size_code = key & 0x3;
+			switch (size_code) {
+			case 0:
+			case 1:
+			case 2:
+				data_len = size_code;
+				break;
+			case 3:
+				data_len = 4;
+				break;
+			default:
+				/* Can't ever happen since size_code is & 0x3 */
+				data_len = 0;
+				break;
+			};
+			key_size = 1;
+		}
+		
+		if (key_cmd == 0x4) {
+			*usage_page  = get_bytes(report_descriptor, size, data_len, i);
+			usage_page_found = 1;
+			//printf("Usage Page: %x\n", (uint32_t)*usage_page);
+		}
+		if (key_cmd == 0x8) {
+			*usage = get_bytes(report_descriptor, size, data_len, i);
+			usage_found = 1;
+			//printf("Usage: %x\n", (uint32_t)*usage);
+		}
+
+		if (usage_page_found && usage_found)
+			return 0; /* success */
+		
+		/* Skip over this key and it's associated data */
+		i += data_len + key_size;
+	}
+	
+	return -1; /* failure */
+}
+#endif // INVASIVE_GET_USAGE
+
+
+/* Get the first language the device says it reports. This comes from
+   USB string #0. */
+static uint16_t get_first_language(libusb_device_handle *dev)
+{
+	uint16_t buf[32];
+	int len;
+	
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			0x0, /* String ID */
+			0x0, /* Language */
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 4)
+		return 0x0;
+	
+	return buf[1]; // First two bytes are len and descriptor type.
+}
+
+static int is_language_supported(libusb_device_handle *dev, uint16_t lang)
+{
+	uint16_t buf[32];
+	int len;
+	int i;
+	
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			0x0, /* String ID */
+			0x0, /* Language */
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 4)
+		return 0x0;
+	
+	
+	len /= 2; /* language IDs are two-bytes each. */
+	/* Start at index 1 because there are two bytes of protocol data. */
+	for (i = 1; i < len; i++) {
+		if (buf[i] == lang)
+			return 1;
+	}
+
+	return 0;
+}
+
+
+/* This function returns a newly allocated wide string containing the USB
+   device string numbered by the index. The returned string must be freed
+   by using free(). */
+static wchar_t *get_usb_string(libusb_device_handle *dev, uint8_t idx)
+{
+	char buf[512];
+	int len;
+	wchar_t *str = NULL;
+	wchar_t wbuf[256];
+
+	/* iconv variables */
+	iconv_t ic;
+	size_t inbytes;
+	size_t outbytes;
+	size_t res;
+	char *inptr;
+	char *outptr;
+
+	/* Determine which language to use. */
+	uint16_t lang;
+	lang = get_usb_code_for_current_locale();
+	if (!is_language_supported(dev, lang))
+		lang = get_first_language(dev);
+		
+	/* Get the string from libusb. */
+	len = libusb_get_string_descriptor(dev,
+			idx,
+			lang,
+			(unsigned char*)buf,
+			sizeof(buf));
+	if (len < 0)
+		return NULL;
+	
+	buf[sizeof(buf)-1] = '\0';
+	
+	if (len+1 < sizeof(buf))
+		buf[len+1] = '\0';
+	
+	/* Initialize iconv. */
+	ic = iconv_open("UTF-32", "UTF-16");
+	if (ic == (iconv_t)-1)
+		return NULL;
+	
+	/* Convert to UTF-32 (wchar_t on glibc 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)
+		goto err;
+
+	/* Write the terminating NULL. */
+	wbuf[sizeof(wbuf)/sizeof(wbuf[0])-1] = 0x00000000;
+	if (outbytes >= sizeof(wbuf[0]))
+		*((wchar_t*)outptr) = 0x00000000;
+	
+	/* Allocate and copy the string. */
+	str = wcsdup(wbuf+1);
+
+err:
+	iconv_close(ic);
+	
+	return str;
+}
+
+static char *make_path(libusb_device *dev, int interface_number)
+{
+	char str[64];
+	snprintf(str, sizeof(str), "%04x:%04x:%02x",
+		libusb_get_bus_number(dev),
+		libusb_get_device_address(dev),
+		interface_number);
+	str[sizeof(str)-1] = '\0';
+	
+	return strdup(str);
+}
+
+
+int HID_API_EXPORT hid_init(void)
+{
+	if (!initialized) {
+		if (libusb_init(NULL))
+			return -1;
+		initialized = 1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	if (initialized) {
+		libusb_exit(NULL);
+		initialized = 0;
+	}
+
+	return 0;
+}
+
+struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	libusb_device **devs;
+	libusb_device *dev;
+	libusb_device_handle *handle;
+	ssize_t num_devs;
+	int i = 0;
+	
+	struct hid_device_info *root = NULL; // return object
+	struct hid_device_info *cur_dev = NULL;
+	
+	setlocale(LC_ALL,"");
+	
+	if (!initialized)
+		hid_init();
+
+	num_devs = libusb_get_device_list(NULL, &devs);
+	if (num_devs < 0)
+		return NULL;
+	while ((dev = devs[i++]) != NULL) {
+		struct libusb_device_descriptor desc;
+		struct libusb_config_descriptor *conf_desc = NULL;
+		int j, k;
+		int interface_num = 0;
+
+		int res = libusb_get_device_descriptor(dev, &desc);
+		unsigned short dev_vid = desc.idVendor;
+		unsigned short dev_pid = desc.idProduct;
+		
+		/* HID's are defined at the interface level. */
+		if (desc.bDeviceClass != LIBUSB_CLASS_PER_INTERFACE)
+			continue;
+
+		res = libusb_get_active_config_descriptor(dev, &conf_desc);
+		if (res < 0)
+			libusb_get_config_descriptor(dev, 0, &conf_desc);
+		if (conf_desc) {
+			for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+				const struct libusb_interface *intf = &conf_desc->interface[j];
+				for (k = 0; k < intf->num_altsetting; k++) {
+					const struct libusb_interface_descriptor *intf_desc;
+					intf_desc = &intf->altsetting[k];
+					if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+						interface_num = intf_desc->bInterfaceNumber;
+
+						/* 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;
+
+							/* VID/PID match. Create the record. */
+							tmp = calloc(1, sizeof(struct hid_device_info));
+							if (cur_dev) {
+								cur_dev->next = tmp;
+							}
+							else {
+								root = tmp;
+							}
+							cur_dev = tmp;
+							
+							/* Fill out the record */
+							cur_dev->next = NULL;
+							cur_dev->path = make_path(dev, interface_num);
+							
+							res = libusb_open(dev, &handle);
+
+							if (res >= 0) {
+								/* Serial Number */
+								if (desc.iSerialNumber > 0)
+									cur_dev->serial_number =
+										get_usb_string(handle, desc.iSerialNumber);
+
+								/* Manufacturer and Product strings */
+								if (desc.iManufacturer > 0)
+									cur_dev->manufacturer_string =
+										get_usb_string(handle, desc.iManufacturer);
+								if (desc.iProduct > 0)
+									cur_dev->product_string =
+										get_usb_string(handle, desc.iProduct);
+
+#ifdef INVASIVE_GET_USAGE
+							/*
+							This section is removed because it is too
+							invasive on the system. Getting a Usage Page
+							and Usage requires parsing the HID Report
+							descriptor. Getting a HID Report descriptor
+							involves claiming the interface. Claiming the
+							interface involves detaching the kernel driver.
+							Detaching the kernel driver is hard on the system
+							because it will unclaim interfaces (if another
+							app has them claimed) and the re-attachment of
+							the driver will sometimes change /dev entry names.
+							It is for these reasons that this section is
+							#if 0. For composite devices, use the interface
+							field in the hid_device_info struct to distinguish
+							between interfaces. */
+								int detached = 0;
+								unsigned char data[256];
+							
+								/* Usage Page and Usage */
+								res = libusb_kernel_driver_active(handle, interface_num);
+								if (res == 1) {
+									res = libusb_detach_kernel_driver(handle, interface_num);
+									if (res < 0)
+										LOG("Couldn't detach kernel driver, even though a kernel driver was attached.");
+									else
+										detached = 1;
+								}
+								res = libusb_claim_interface(handle, interface_num);
+								if (res >= 0) {
+									/* Get the HID Report Descriptor. */
+									res = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_INTERFACE, LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_REPORT << 8)|interface_num, 0, data, sizeof(data), 5000);
+									if (res >= 0) {
+										unsigned short page=0, usage=0;
+										/* Parse the usage and usage page
+										   out of the report descriptor. */
+										get_usage(data, res,  &page, &usage);
+										cur_dev->usage_page = page;
+										cur_dev->usage = usage;
+									}
+									else
+										LOG("libusb_control_transfer() for getting the HID report failed with %d\n", res);
+
+									/* Release the interface */
+									res = libusb_release_interface(handle, interface_num);
+									if (res < 0)
+										LOG("Can't release the interface.\n");
+								}
+								else
+									LOG("Can't claim interface %d\n", res);
+
+								/* 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 /*******************/
+
+								libusb_close(handle);
+							}
+							/* VID/PID */
+							cur_dev->vendor_id = dev_vid;
+							cur_dev->product_id = dev_pid;
+
+							/* Release Number */
+							cur_dev->release_number = desc.bcdDevice;
+							
+							/* Interface Number */
+							cur_dev->interface_number = interface_num;
+						}
+					}
+				} /* altsettings */
+			} /* interfaces */
+			libusb_free_config_descriptor(conf_desc);
+		}
+	}
+
+	libusb_free_device_list(devs, 1);
+
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+{
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+	
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+	
+	return handle;
+}
+
+static void read_callback(struct libusb_transfer *transfer)
+{
+	hid_device *dev = transfer->user_data;
+	
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+
+		struct input_report *rpt = malloc(sizeof(*rpt));
+		rpt->data = malloc(transfer->actual_length);
+		memcpy(rpt->data, transfer->buffer, transfer->actual_length);
+		rpt->len = transfer->actual_length;
+		rpt->next = NULL;
+
+		pthread_mutex_lock(&dev->mutex);
+
+		/* Attach the new report object to the end of the list. */
+		if (dev->input_reports == NULL) {
+			/* The list is empty. Put it at the root. */
+			dev->input_reports = rpt;
+			pthread_cond_signal(&dev->condition);
+		}
+		else {
+			/* Find the end of the list and attach. */
+			struct input_report *cur = dev->input_reports;
+			int num_queued = 0;
+			while (cur->next != NULL) {
+				cur = cur->next;
+				num_queued++;
+			}
+			cur->next = rpt;
+			
+			/* Pop one off if we've reached 30 in the queue. This
+			   way we don't grow forever if the user never reads
+			   anything from the device. */
+			if (num_queued > 30) {
+				return_data(dev, NULL, 0);
+			}			
+		}
+		pthread_mutex_unlock(&dev->mutex);
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
+		dev->shutdown_thread = 1;
+		return;
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) {
+		dev->shutdown_thread = 1;
+		return;
+	}
+	else if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
+		//LOG("Timeout (normal)\n");
+	}
+	else {
+		LOG("Unknown transfer code: %d\n", transfer->status);
+	}
+	
+	/* Re-submit the transfer object. */
+	libusb_submit_transfer(transfer);
+}
+
+
+static void *read_thread(void *param)
+{
+	hid_device *dev = param;
+	unsigned char *buf;
+	const size_t length = dev->input_ep_max_packet_size;
+
+	/* Set up the transfer object. */
+	buf = malloc(length);
+	dev->transfer = libusb_alloc_transfer(0);
+	libusb_fill_interrupt_transfer(dev->transfer,
+		dev->device_handle,
+		dev->input_endpoint,
+		buf,
+		length,
+		read_callback,
+		dev,
+		5000/*timeout*/);
+	
+	/* Make the first submission. Further submissions are made
+	   from inside read_callback() */
+	libusb_submit_transfer(dev->transfer);
+
+	// Notify the main thread that the read thread is up and running.
+	pthread_barrier_wait(&dev->barrier);
+	
+	/* Handle all the events. */
+	while (!dev->shutdown_thread) {
+		int res;
+		res = libusb_handle_events(NULL);
+		if (res < 0) {
+			/* There was an error. Break out of this loop. */
+			break;
+		}
+	}
+	
+	/* Cancel any transfer that may be pending. This call will fail
+	   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);
+	}
+	
+	/* Now that the read thread is stopping, Wake any threads which are
+	   waiting on data (in hid_read_timeout()). Do this under a mutex to
+	   make sure that a thread which is about to go to sleep waiting on
+	   the condition acutally will go to sleep before the condition is
+	   signaled. */
+	pthread_mutex_lock(&dev->mutex);
+	pthread_cond_broadcast(&dev->condition);
+	pthread_mutex_unlock(&dev->mutex);
+
+	/* The dev->transfer->buffer and dev->transfer objects are cleaned up
+	   in hid_close(). They are not cleaned up here because this thread
+	   could end either due to a disconnect or due to a user
+	   call to hid_close(). In both cases the objects can be safely
+	   cleaned up after the call to pthread_join() (in hid_close()), but
+	   since hid_close() calls libusb_cancel_transfer(), on these objects,
+	   they can not be cleaned up here. */
+	
+	return NULL;
+}
+
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+	hid_device *dev = NULL;
+
+	dev = new_hid_device();
+
+	libusb_device **devs;
+	libusb_device *usb_dev;
+	ssize_t num_devs;
+	int res;
+	int d = 0;
+	int good_open = 0;
+	
+	setlocale(LC_ALL,"");
+	
+	if (!initialized)
+		hid_init();
+
+	num_devs = libusb_get_device_list(NULL, &devs);
+	while ((usb_dev = devs[d++]) != NULL) {
+		struct libusb_device_descriptor desc;
+		struct libusb_config_descriptor *conf_desc = NULL;
+		int i,j,k;
+		libusb_get_device_descriptor(usb_dev, &desc);
+
+		if (libusb_get_active_config_descriptor(usb_dev, &conf_desc) < 0)
+			continue;
+		for (j = 0; j < conf_desc->bNumInterfaces; j++) {
+			const struct libusb_interface *intf = &conf_desc->interface[j];
+			for (k = 0; k < intf->num_altsetting; k++) {
+				const struct libusb_interface_descriptor *intf_desc;
+				intf_desc = &intf->altsetting[k];
+				if (intf_desc->bInterfaceClass == LIBUSB_CLASS_HID) {
+					char *dev_path = make_path(usb_dev, intf_desc->bInterfaceNumber);
+					if (!strcmp(dev_path, path)) {
+						/* Matched Paths. Open this device */
+
+						// OPEN HERE //
+						res = libusb_open(usb_dev, &dev->device_handle);
+						if (res < 0) {
+							LOG("can't open device\n");
+							free(dev_path);
+ 							break;
+						}
+						good_open = 1;
+						
+						/* 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) {
+							res = libusb_detach_kernel_driver(dev->device_handle, intf_desc->bInterfaceNumber);
+							if (res < 0) {
+								libusb_close(dev->device_handle);
+								LOG("Unable to detach Kernel Driver\n");
+								free(dev_path);
+								good_open = 0;
+								break;
+							}
+						}
+						
+						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);
+							free(dev_path);
+							libusb_close(dev->device_handle);
+							good_open = 0;
+							break;
+						}
+
+						/* Store off the string descriptor indexes */
+						dev->manufacturer_index = desc.iManufacturer;
+						dev->product_index      = desc.iProduct;
+						dev->serial_index       = desc.iSerialNumber;
+
+						/* Store off the interface number */
+						dev->interface = intf_desc->bInterfaceNumber;
+												
+						/* Find the INPUT and OUTPUT endpoints. An
+						   OUTPUT endpoint is not required. */
+						for (i = 0; i < intf_desc->bNumEndpoints; i++) {
+							const struct libusb_endpoint_descriptor *ep
+								= &intf_desc->endpoint[i];
+
+							/* Determine the type and direction of this
+							   endpoint. */
+							int is_interrupt =
+								(ep->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+							      == LIBUSB_TRANSFER_TYPE_INTERRUPT;
+							int is_output = 
+								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+							      == LIBUSB_ENDPOINT_OUT;
+							int is_input = 
+								(ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK)
+							      == LIBUSB_ENDPOINT_IN;
+
+							/* Decide whether to use it for intput or output. */
+							if (dev->input_endpoint == 0 &&
+							    is_interrupt && is_input) {
+								/* Use this endpoint for INPUT */
+								dev->input_endpoint = ep->bEndpointAddress;
+								dev->input_ep_max_packet_size = ep->wMaxPacketSize;
+							}
+							if (dev->output_endpoint == 0 &&
+							    is_interrupt && is_output) {
+								/* Use this endpoint for OUTPUT */
+								dev->output_endpoint = ep->bEndpointAddress;
+							}
+						}
+						
+						pthread_create(&dev->thread, NULL, read_thread, dev);
+						
+						// Wait here for the read thread to be initialized.
+						pthread_barrier_wait(&dev->barrier);
+						
+					}
+					free(dev_path);
+				}
+			}
+		}
+		libusb_free_config_descriptor(conf_desc);
+
+	}
+
+	libusb_free_device_list(devs, 1);
+	
+	// If we have a good handle, return it.
+	if (good_open) {
+		return dev;
+	}
+	else {
+		// Unable to open any devices.
+		free_hid_device(dev);
+		return NULL;
+	}
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res;
+	int report_number = data[0];
+	int skipped_report_id = 0;
+
+	if (report_number == 0x0) {
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+
+
+	if (dev->output_endpoint <= 0) {
+		/* No interrput out endpoint. Use the Control Endpoint */
+		res = libusb_control_transfer(dev->device_handle,
+			LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+			0x09/*HID Set_Report*/,
+			(2/*HID output*/ << 8) | report_number,
+			dev->interface,
+			(unsigned char *)data, length,
+			1000/*timeout millis*/);
+		
+		if (res < 0)
+			return -1;
+		
+		if (skipped_report_id)
+			length++;
+		
+		return length;
+	}
+	else {
+		/* Use the interrupt out endpoint */
+		int actual_length;
+		res = libusb_interrupt_transfer(dev->device_handle,
+			dev->output_endpoint,
+			(unsigned char*)data,
+			length,
+			&actual_length, 1000);
+		
+		if (res < 0)
+			return -1;
+		
+		if (skipped_report_id)
+			actual_length++;
+		
+		return actual_length;
+	}
+}
+
+/* Helper function, to simplify hid_read().
+   This should be called with dev->mutex locked. */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+	/* Copy the data out of the linked list item (rpt) into the
+	   return buffer (data), and delete the liked list item. */
+	struct input_report *rpt = dev->input_reports;
+	size_t len = (length < rpt->len)? length: rpt->len;
+	if (len > 0)
+		memcpy(data, rpt->data, len);
+	dev->input_reports = rpt->next;
+	free(rpt->data);
+	free(rpt);
+	return len;
+}
+
+static void cleanup_mutex(void *param)
+{
+	hid_device *dev = param;
+	pthread_mutex_unlock(&dev->mutex);
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	int bytes_read = -1;
+
+#if 0
+	int transferred;
+	int res = libusb_interrupt_transfer(dev->device_handle, dev->input_endpoint, data, length, &transferred, 5000);
+	LOG("transferred: %d\n", transferred);
+	return transferred;
+#endif
+
+	pthread_mutex_lock(&dev->mutex);
+	pthread_cleanup_push(&cleanup_mutex, dev);
+
+	/* There's an input report queued up. Return it. */
+	if (dev->input_reports) {
+		/* Return the first one */
+		bytes_read = return_data(dev, data, length);
+		goto ret;
+	}
+	
+	if (dev->shutdown_thread) {
+		/* This means the device has been disconnected.
+		   An error code of -1 should be returned. */
+		bytes_read = -1;
+		goto ret;
+	}
+	
+	if (milliseconds == -1) {
+		/* Blocking */
+		while (!dev->input_reports && !dev->shutdown_thread) {
+			pthread_cond_wait(&dev->condition, &dev->mutex);
+		}
+		if (dev->input_reports) {
+			bytes_read = return_data(dev, data, length);
+		}
+	}
+	else if (milliseconds > 0) {
+		/* Non-blocking, but called with timeout. */
+		int res;
+		struct timespec ts;
+		clock_gettime(CLOCK_REALTIME, &ts);
+		ts.tv_sec += milliseconds / 1000;
+		ts.tv_nsec += (milliseconds % 1000) * 1000000;
+		if (ts.tv_nsec >= 1000000000L) {
+			ts.tv_sec++;
+			ts.tv_nsec -= 1000000000L;
+		}
+		
+		while (!dev->input_reports && !dev->shutdown_thread) {
+			res = pthread_cond_timedwait(&dev->condition, &dev->mutex, &ts);
+			if (res == 0) {
+				if (dev->input_reports) {
+					bytes_read = return_data(dev, data, length);
+					break;
+				}
+				
+				/* If we're here, there was a spurious wake up
+				   or the read thread was shutdown. Run the
+				   loop again (ie: don't break). */
+			}
+			else if (res == ETIMEDOUT) {
+				/* Timed out. */
+				bytes_read = 0;
+				break;
+			}
+			else {
+				/* Error. */
+				bytes_read = -1;
+				break;
+			}
+		}
+	}
+	else {
+		/* Purely non-blocking */
+		bytes_read = 0;
+	}
+
+ret:
+	pthread_mutex_unlock(&dev->mutex);
+	pthread_cleanup_pop(0);
+
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, dev->blocking ? -1 : 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	dev->blocking = !nonblock;
+	
+	return 0;
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res = -1;
+	int skipped_report_id = 0;
+	int report_number = data[0];
+
+	if (report_number == 0x0) {
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+
+	res = libusb_control_transfer(dev->device_handle,
+		LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_OUT,
+		0x09/*HID set_report*/,
+		(3/*HID feature*/ << 8) | report_number,
+		dev->interface,
+		(unsigned char *)data, length,
+		1000/*timeout millis*/);
+	
+	if (res < 0)
+		return -1;
+	
+	/* Account for the report ID */
+	if (skipped_report_id)
+		length++;
+	
+	return length;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	int res = -1;
+	int skipped_report_id = 0;
+	int report_number = data[0];
+
+	if (report_number == 0x0) {
+		/* Offset the return buffer by 1, so that the report ID
+		   will remain in byte 0. */
+		data++;
+		length--;
+		skipped_report_id = 1;
+	}
+	res = libusb_control_transfer(dev->device_handle,
+		LIBUSB_REQUEST_TYPE_CLASS|LIBUSB_RECIPIENT_INTERFACE|LIBUSB_ENDPOINT_IN,
+		0x01/*HID get_report*/,
+		(3/*HID feature*/ << 8) | report_number,
+		dev->interface,
+		(unsigned char *)data, length,
+		1000/*timeout millis*/);
+	
+	if (res < 0)
+		return -1;
+
+	if (skipped_report_id)
+		res++;
+	
+	return res;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+	
+	/* Cause read_thread() to stop. */
+	dev->shutdown_thread = 1;
+	libusb_cancel_transfer(dev->transfer);
+
+	/* Wait for read_thread() to end. */
+	pthread_join(dev->thread, NULL);
+	
+	/* Clean up the Transfer objects allocated in read_thread(). */
+	free(dev->transfer->buffer);
+	libusb_free_transfer(dev->transfer);
+	
+	/* release the interface */
+	libusb_release_interface(dev->device_handle, dev->interface);
+	
+	/* Close the handle */
+	libusb_close(dev->device_handle);
+	
+	/* Clear out the queue of received reports. */
+	pthread_mutex_lock(&dev->mutex);
+	while (dev->input_reports) {
+		return_data(dev, NULL, 0);
+	}
+	pthread_mutex_unlock(&dev->mutex);
+	
+	free_hid_device(dev);
+}
+
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->manufacturer_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->product_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return hid_get_indexed_string(dev, dev->serial_index, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	wchar_t *str;
+
+	str = get_usb_string(dev->device_handle, string_index);
+	if (str) {
+		wcsncpy(string, str, maxlen);
+		string[maxlen-1] = L'\0';
+		free(str);
+		return 0;
+	}
+	else
+		return -1;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	return NULL;
+}
+
+
+struct lang_map_entry {
+	const char *name;
+	const char *string_code;
+	uint16_t usb_code;
+};
+
+#define LANG(name,code,usb_code) { name, code, usb_code }
+static struct lang_map_entry lang_map[] = {
+	LANG("Afrikaans", "af", 0x0436),
+	LANG("Albanian", "sq", 0x041C),
+	LANG("Arabic - United Arab Emirates", "ar_ae", 0x3801),
+	LANG("Arabic - Bahrain", "ar_bh", 0x3C01),
+	LANG("Arabic - Algeria", "ar_dz", 0x1401),
+	LANG("Arabic - Egypt", "ar_eg", 0x0C01),
+	LANG("Arabic - Iraq", "ar_iq", 0x0801),
+	LANG("Arabic - Jordan", "ar_jo", 0x2C01),
+	LANG("Arabic - Kuwait", "ar_kw", 0x3401),
+	LANG("Arabic - Lebanon", "ar_lb", 0x3001),
+	LANG("Arabic - Libya", "ar_ly", 0x1001),
+	LANG("Arabic - Morocco", "ar_ma", 0x1801),
+	LANG("Arabic - Oman", "ar_om", 0x2001),
+	LANG("Arabic - Qatar", "ar_qa", 0x4001),
+	LANG("Arabic - Saudi Arabia", "ar_sa", 0x0401),
+	LANG("Arabic - Syria", "ar_sy", 0x2801),
+	LANG("Arabic - Tunisia", "ar_tn", 0x1C01),
+	LANG("Arabic - Yemen", "ar_ye", 0x2401),
+	LANG("Armenian", "hy", 0x042B),
+	LANG("Azeri - Latin", "az_az", 0x042C),
+	LANG("Azeri - Cyrillic", "az_az", 0x082C),
+	LANG("Basque", "eu", 0x042D),
+	LANG("Belarusian", "be", 0x0423),
+	LANG("Bulgarian", "bg", 0x0402),
+	LANG("Catalan", "ca", 0x0403),
+	LANG("Chinese - China", "zh_cn", 0x0804),
+	LANG("Chinese - Hong Kong SAR", "zh_hk", 0x0C04),
+	LANG("Chinese - Macau SAR", "zh_mo", 0x1404),
+	LANG("Chinese - Singapore", "zh_sg", 0x1004),
+	LANG("Chinese - Taiwan", "zh_tw", 0x0404),
+	LANG("Croatian", "hr", 0x041A),
+	LANG("Czech", "cs", 0x0405),
+	LANG("Danish", "da", 0x0406),
+	LANG("Dutch - Netherlands", "nl_nl", 0x0413),
+	LANG("Dutch - Belgium", "nl_be", 0x0813),
+	LANG("English - Australia", "en_au", 0x0C09),
+	LANG("English - Belize", "en_bz", 0x2809),
+	LANG("English - Canada", "en_ca", 0x1009),
+	LANG("English - Caribbean", "en_cb", 0x2409),
+	LANG("English - Ireland", "en_ie", 0x1809),
+	LANG("English - Jamaica", "en_jm", 0x2009),
+	LANG("English - New Zealand", "en_nz", 0x1409),
+	LANG("English - Phillippines", "en_ph", 0x3409),
+	LANG("English - Southern Africa", "en_za", 0x1C09),
+	LANG("English - Trinidad", "en_tt", 0x2C09),
+	LANG("English - Great Britain", "en_gb", 0x0809),
+	LANG("English - United States", "en_us", 0x0409),
+	LANG("Estonian", "et", 0x0425),
+	LANG("Farsi", "fa", 0x0429),
+	LANG("Finnish", "fi", 0x040B),
+	LANG("Faroese", "fo", 0x0438),
+	LANG("French - France", "fr_fr", 0x040C),
+	LANG("French - Belgium", "fr_be", 0x080C),
+	LANG("French - Canada", "fr_ca", 0x0C0C),
+	LANG("French - Luxembourg", "fr_lu", 0x140C),
+	LANG("French - Switzerland", "fr_ch", 0x100C),
+	LANG("Gaelic - Ireland", "gd_ie", 0x083C),
+	LANG("Gaelic - Scotland", "gd", 0x043C),
+	LANG("German - Germany", "de_de", 0x0407),
+	LANG("German - Austria", "de_at", 0x0C07),
+	LANG("German - Liechtenstein", "de_li", 0x1407),
+	LANG("German - Luxembourg", "de_lu", 0x1007),
+	LANG("German - Switzerland", "de_ch", 0x0807),
+	LANG("Greek", "el", 0x0408),
+	LANG("Hebrew", "he", 0x040D),
+	LANG("Hindi", "hi", 0x0439),
+	LANG("Hungarian", "hu", 0x040E),
+	LANG("Icelandic", "is", 0x040F),
+	LANG("Indonesian", "id", 0x0421),
+	LANG("Italian - Italy", "it_it", 0x0410),
+	LANG("Italian - Switzerland", "it_ch", 0x0810),
+	LANG("Japanese", "ja", 0x0411),
+	LANG("Korean", "ko", 0x0412),
+	LANG("Latvian", "lv", 0x0426),
+	LANG("Lithuanian", "lt", 0x0427),
+	LANG("F.Y.R.O. Macedonia", "mk", 0x042F),
+	LANG("Malay - Malaysia", "ms_my", 0x043E),
+	LANG("Malay – Brunei", "ms_bn", 0x083E),
+	LANG("Maltese", "mt", 0x043A),
+	LANG("Marathi", "mr", 0x044E),
+	LANG("Norwegian - Bokml", "no_no", 0x0414),
+	LANG("Norwegian - Nynorsk", "no_no", 0x0814),
+	LANG("Polish", "pl", 0x0415),
+	LANG("Portuguese - Portugal", "pt_pt", 0x0816),
+	LANG("Portuguese - Brazil", "pt_br", 0x0416),
+	LANG("Raeto-Romance", "rm", 0x0417),
+	LANG("Romanian - Romania", "ro", 0x0418),
+	LANG("Romanian - Republic of Moldova", "ro_mo", 0x0818),
+	LANG("Russian", "ru", 0x0419),
+	LANG("Russian - Republic of Moldova", "ru_mo", 0x0819),
+	LANG("Sanskrit", "sa", 0x044F),
+	LANG("Serbian - Cyrillic", "sr_sp", 0x0C1A),
+	LANG("Serbian - Latin", "sr_sp", 0x081A),
+	LANG("Setsuana", "tn", 0x0432),
+	LANG("Slovenian", "sl", 0x0424),
+	LANG("Slovak", "sk", 0x041B),
+	LANG("Sorbian", "sb", 0x042E),
+	LANG("Spanish - Spain (Traditional)", "es_es", 0x040A),
+	LANG("Spanish - Argentina", "es_ar", 0x2C0A),
+	LANG("Spanish - Bolivia", "es_bo", 0x400A),
+	LANG("Spanish - Chile", "es_cl", 0x340A),
+	LANG("Spanish - Colombia", "es_co", 0x240A),
+	LANG("Spanish - Costa Rica", "es_cr", 0x140A),
+	LANG("Spanish - Dominican Republic", "es_do", 0x1C0A),
+	LANG("Spanish - Ecuador", "es_ec", 0x300A),
+	LANG("Spanish - Guatemala", "es_gt", 0x100A),
+	LANG("Spanish - Honduras", "es_hn", 0x480A),
+	LANG("Spanish - Mexico", "es_mx", 0x080A),
+	LANG("Spanish - Nicaragua", "es_ni", 0x4C0A),
+	LANG("Spanish - Panama", "es_pa", 0x180A),
+	LANG("Spanish - Peru", "es_pe", 0x280A),
+	LANG("Spanish - Puerto Rico", "es_pr", 0x500A),
+	LANG("Spanish - Paraguay", "es_py", 0x3C0A),
+	LANG("Spanish - El Salvador", "es_sv", 0x440A),
+	LANG("Spanish - Uruguay", "es_uy", 0x380A),
+	LANG("Spanish - Venezuela", "es_ve", 0x200A),
+	LANG("Southern Sotho", "st", 0x0430),
+	LANG("Swahili", "sw", 0x0441),
+	LANG("Swedish - Sweden", "sv_se", 0x041D),
+	LANG("Swedish - Finland", "sv_fi", 0x081D),
+	LANG("Tamil", "ta", 0x0449),
+	LANG("Tatar", "tt", 0X0444),
+	LANG("Thai", "th", 0x041E),
+	LANG("Turkish", "tr", 0x041F),
+	LANG("Tsonga", "ts", 0x0431),
+	LANG("Ukrainian", "uk", 0x0422),
+	LANG("Urdu", "ur", 0x0420),
+	LANG("Uzbek - Cyrillic", "uz_uz", 0x0843),
+	LANG("Uzbek – Latin", "uz_uz", 0x0443),
+	LANG("Vietnamese", "vi", 0x042A),
+	LANG("Xhosa", "xh", 0x0434),
+	LANG("Yiddish", "yi", 0x043D),
+	LANG("Zulu", "zu", 0x0435),
+	LANG(NULL, NULL, 0x0),	
+};
+
+uint16_t get_usb_code_for_current_locale(void)
+{
+	char *locale;
+	char search_string[64];
+	char *ptr;
+	
+	/* Get the current locale. */
+	locale = setlocale(0, NULL);
+	if (!locale)
+		return 0x0;
+	
+	/* Make a copy of the current locale string. */
+	strncpy(search_string, locale, sizeof(search_string));
+	search_string[sizeof(search_string)-1] = '\0';
+	
+	/* Chop off the encoding part, and make it lower case. */
+	ptr = search_string;
+	while (*ptr) {
+		*ptr = tolower(*ptr);
+		if (*ptr == '.') {
+			*ptr = '\0';
+			break;
+		}
+		ptr++;
+	}
+
+	/* Find the entry which matches the string code of our locale. */
+	struct lang_map_entry *lang = lang_map;
+	while (lang->string_code) {
+		if (!strcmp(lang->string_code, search_string)) {
+			return lang->usb_code;
+		}	
+		lang++;
+	}
+	
+	/* There was no match. Find with just the language only. */
+	/* Chop off the variant. Chop it off at the '_'. */
+	ptr = search_string;
+	while (*ptr) {
+		*ptr = tolower(*ptr);
+		if (*ptr == '_') {
+			*ptr = '\0';
+			break;
+		}
+		ptr++;
+	}
+	
+#if 0 // TODO: Do we need this?
+	/* Find the entry which matches the string code of our language. */
+	lang = lang_map;
+	while (lang->string_code) {
+		if (!strcmp(lang->string_code, search_string)) {
+			return lang->usb_code;
+		}	
+		lang++;
+	}
+#endif
+	
+	/* Found nothing. */
+	return 0x0;
+}
+
+#ifdef __cplusplus
+}
+#endif

=== added file 'mixxx/lib/hidapi-0.7.0/linux/hid.c'
--- mixxx/lib/hidapi-0.7.0/linux/hid.c	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/linux/hid.c	2012-04-07 14:24:23 +0000
@@ -0,0 +1,595 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+ Linux Version - 6/2/2009
+
+ Copyright 2009, All Rights Reserved.
+ 
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/* C */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <errno.h>
+
+/* Unix */
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <fcntl.h>
+#include <poll.h>
+
+/* Linux */
+#include <linux/hidraw.h>
+#include <linux/version.h>
+#include <libudev.h>
+
+#include "hidapi.h"
+
+/* Definitions from linux/hidraw.h. Since these are new, some distros
+   may not have header files which contain them. */
+#ifndef HIDIOCSFEATURE
+#define HIDIOCSFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
+#endif
+#ifndef HIDIOCGFEATURE
+#define HIDIOCGFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
+#endif
+
+struct hid_device_ {
+	int device_handle;
+	int blocking;
+	int uses_numbered_reports;
+};
+
+
+static __u32 kernel_version = 0;
+
+hid_device *new_hid_device()
+{
+	hid_device *dev = calloc(1, sizeof(hid_device));
+	dev->device_handle = -1;
+	dev->blocking = 1;
+	dev->uses_numbered_reports = 0;
+
+	return dev;
+}
+
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+
+/* 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;
+}
+
+/* uses_numbered_reports() returns 1 if report_descriptor describes a device
+   which contains numbered reports. */ 
+static int uses_numbered_reports(__u8 *report_descriptor, __u32 size) {
+	int i = 0;
+	int size_code;
+	int data_len, key_size;
+	
+	while (i < size) {
+		int key = report_descriptor[i];
+
+		/* Check for the Report ID key */
+		if (key == 0x85/*Report ID*/) {
+			/* This device has a Report ID, which means it uses
+			   numbered reports. */
+			return 1;
+		}
+		
+		//printf("key: %02hhx\n", key);
+		
+		if ((key & 0xf0) == 0xf0) {
+			/* This is a Long Item. The next byte contains the
+			   length of the data section (value) for this key.
+			   See the HID specification, version 1.11, section
+			   6.2.2.3, titled "Long Items." */
+			if (i+1 < size)
+				data_len = report_descriptor[i+1];
+			else
+				data_len = 0; /* malformed report */
+			key_size = 3;
+		}
+		else {
+			/* This is a Short Item. The bottom two bits of the
+			   key contain the size code for the data section
+			   (value) for this key.  Refer to the HID
+			   specification, version 1.11, section 6.2.2.2,
+			   titled "Short Items." */
+			size_code = key & 0x3;
+			switch (size_code) {
+			case 0:
+			case 1:
+			case 2:
+				data_len = size_code;
+				break;
+			case 3:
+				data_len = 4;
+				break;
+			default:
+				/* Can't ever happen since size_code is & 0x3 */
+				data_len = 0;
+				break;
+			};
+			key_size = 1;
+		}
+		
+		/* Skip over this key and it's associated data */
+		i += data_len + key_size;
+	}
+	
+	/* Didn't find a Report ID key. Device doesn't use numbered reports. */
+	return 0;
+}
+
+static int get_device_string(hid_device *dev, const char *key, wchar_t *string, size_t maxlen)
+{
+	struct udev *udev;
+	struct udev_device *udev_dev, *parent;
+	struct stat s;
+	int ret = -1;
+	
+	setlocale(LC_ALL,"");
+
+	/* Create the udev object */
+	udev = udev_new();
+	if (!udev) {
+		printf("Can't create udev\n");
+		return -1;
+	}
+
+	/* Get the dev_t (major/minor numbers) from the file handle. */
+	fstat(dev->device_handle, &s);
+	/* 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;
+			}
+		}
+	}
+
+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.
+	udev_unref(udev);
+
+	return ret;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+	/* Nothing to do for this in the Linux/hidraw implementation. */
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	/* Nothing to do for this in the Linux/hidraw implementation. */
+	return 0;
+}
+
+struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	struct udev *udev;
+	struct udev_enumerate *enumerate;
+	struct udev_list_entry *devices, *dev_list_entry;
+	
+	struct hid_device_info *root = NULL; // return object
+	struct hid_device_info *cur_dev = NULL;
+	
+	setlocale(LC_ALL,"");
+
+	/* Create the udev object */
+	udev = udev_new();
+	if (!udev) {
+		printf("Can't create udev\n");
+		return NULL;
+	}
+
+	/* Create a list of the devices in the 'hidraw' subsystem. */
+	enumerate = udev_enumerate_new(udev);
+	udev_enumerate_add_match_subsystem(enumerate, "hidraw");
+	udev_enumerate_scan_devices(enumerate);
+	devices = udev_enumerate_get_list_entry(enumerate);
+	/* For each item, see if it matches the vid/pid, and if so
+	   create a udev_device record for it */
+	udev_list_entry_foreach(dev_list_entry, devices) {
+		const char *sysfs_path;
+		const char *dev_path;
+		const char *str;
+		struct udev_device *hid_dev; // The device's HID udev node.
+		struct udev_device *dev; // The actual hardware device.
+		struct udev_device *intf_dev; // The device's interface (in the USB sense).
+		unsigned short dev_vid;
+		unsigned short dev_pid;
+		
+		/* 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;
+
+		/* 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. */
+			tmp = malloc(sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			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");
+
+			/* 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;
+
+			/* Release Number */
+			str = udev_device_get_sysattr_value(dev, "bcdDevice");
+			cur_dev->release_number = (str)? strtol(str, NULL, 16): 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;
+			}
+		}
+		else
+			goto next;
+
+	next:
+		udev_device_unref(hid_dev);
+		/* 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.  */
+	}
+	/* Free the enumerator and udev objects. */
+	udev_enumerate_unref(enumerate);
+	udev_unref(udev);
+	
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+{
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+	
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+	
+	return handle;
+}
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+	hid_device *dev = NULL;
+
+	dev = new_hid_device();
+
+	if (kernel_version == 0) {
+		struct utsname name;
+		int major, minor, release;
+		int ret;
+		uname(&name);
+		ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release);
+		if (ret == 3) {
+			kernel_version = major << 16 | minor << 8 | release;
+			//printf("Kernel Version: %d\n", kernel_version);
+		}
+		else {
+			printf("Couldn't sscanf() version string %s\n", name.release);
+		}
+	}
+
+	// OPEN HERE //
+	dev->device_handle = open(path, O_RDWR);
+
+	// If we have a good handle, return it.
+	if (dev->device_handle > 0) {
+
+		/* Get the report descriptor */
+		int res, desc_size = 0;
+		struct hidraw_report_descriptor rpt_desc;
+
+		memset(&rpt_desc, 0x0, sizeof(rpt_desc));
+
+		/* Get Report Descriptor Size */
+		res = ioctl(dev->device_handle, HIDIOCGRDESCSIZE, &desc_size);
+		if (res < 0)
+			perror("HIDIOCGRDESCSIZE");
+
+
+		/* Get Report Descriptor */
+		rpt_desc.size = desc_size;
+		res = ioctl(dev->device_handle, HIDIOCGRDESC, &rpt_desc);
+		if (res < 0) {
+			perror("HIDIOCGRDESC");
+		} else {
+			/* Determine if this device uses numbered reports. */
+			dev->uses_numbered_reports =
+				uses_numbered_reports(rpt_desc.value,
+				                      rpt_desc.size);
+		}
+		
+		return dev;
+	}
+	else {
+		// Unable to open any devices.
+		free(dev);
+		return NULL;
+	}
+}
+
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int bytes_written;
+
+	bytes_written = write(dev->device_handle, data, length);
+
+	return bytes_written;
+}
+
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	int bytes_read;
+
+	if (milliseconds != 0) {
+		/* milliseconds is -1 or > 0. In both cases, we want to
+		   call poll() and wait for data to arrive. -1 means
+		   INFINITE. */
+		int ret;
+		struct pollfd fds;
+
+		fds.fd = dev->device_handle;
+		fds.events = POLLIN;
+		fds.revents = 0;
+		ret = poll(&fds, 1, milliseconds);
+		if (ret == -1 || ret == 0)
+			/* Error or timeout */
+			return ret;
+	}
+
+	bytes_read = read(dev->device_handle, data, length);
+	if (bytes_read < 0 && errno == EAGAIN)
+		bytes_read = 0;
+	
+	if (bytes_read >= 0 &&
+	    kernel_version < KERNEL_VERSION(2,6,34) &&
+	    dev->uses_numbered_reports) {
+		/* Work around a kernel bug. Chop off the first byte. */
+		memmove(data, data+1, bytes_read);
+		bytes_read--;
+	}
+
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	int flags, res;
+
+	flags = fcntl(dev->device_handle, F_GETFL, 0);
+	if (flags >= 0) {
+		if (nonblock)
+			res = fcntl(dev->device_handle, F_SETFL, flags | O_NONBLOCK);
+		else
+			res = fcntl(dev->device_handle, F_SETFL, flags & ~O_NONBLOCK);
+	}
+	else
+		return -1;
+
+	if (res < 0) {
+		return -1;
+	}
+	else {
+		dev->blocking = !nonblock;
+		return 0; /* Success */
+	}
+}
+
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	int res;
+
+	res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
+	if (res < 0)
+		perror("ioctl (SFEATURE)");
+
+	return res;
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	int res;
+
+	res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
+	if (res < 0)
+		perror("ioctl (GFEATURE)");
+
+
+	return res;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+	close(dev->device_handle);
+	free(dev);
+}
+
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	return -1;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	return NULL;
+}

=== added directory 'mixxx/lib/hidapi-0.7.0/mac'
=== added file 'mixxx/lib/hidapi-0.7.0/mac/.gitignore'
--- mixxx/lib/hidapi-0.7.0/mac/.gitignore	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/mac/.gitignore	2012-04-07 14:24:23 +0000
@@ -0,0 +1,13 @@
+Debug
+Release
+*.exp
+*.ilk
+*.lib
+*.suo
+*.vcproj.*
+*.ncb
+*.suo
+*.dll
+*.pdb
+*.o
+hidtest
\ No newline at end of file

=== added file 'mixxx/lib/hidapi-0.7.0/mac/Makefile'
--- mixxx/lib/hidapi-0.7.0/mac/Makefile	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/mac/Makefile	2012-04-07 14:24:23 +0000
@@ -0,0 +1,32 @@
+###########################################
+# Simple Makefile for HIDAPI test program
+#
+# Alan Ott
+# Signal 11 Software
+# 2010-07-03
+###########################################
+
+all: hidtest
+
+CC=gcc
+CXX=g++
+COBJS=hid.o
+CPPOBJS=../hidtest/hidtest.o
+OBJS=$(COBJS) $(CPPOBJS)
+CFLAGS+=-I../hidapi -Wall -g -c 
+LIBS=-framework IOKit -framework CoreFoundation
+
+
+hidtest: $(OBJS)
+	g++ -Wall -g $^ $(LIBS) -o hidtest
+
+$(COBJS): %.o: %.c
+	$(CC) $(CFLAGS) $< -o $@
+
+$(CPPOBJS): %.o: %.cpp
+	$(CXX) $(CFLAGS) $< -o $@
+
+clean:
+	rm -f *.o hidtest $(CPPOBJS)
+
+.PHONY: clean

=== added file 'mixxx/lib/hidapi-0.7.0/mac/hid.c'
--- mixxx/lib/hidapi-0.7.0/mac/hid.c	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/mac/hid.c	2012-04-07 14:24:23 +0000
@@ -0,0 +1,1122 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+ 
+ Alan Ott
+ Signal 11 Software
+
+ 2010-07-03
+
+ Copyright 2010, All Rights Reserved.
+ 
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/* See Apple Technical Note TN2187 for details on IOHidManager. */
+
+#include <IOKit/hid/IOHIDManager.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <wchar.h>
+#include <locale.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "hidapi.h"
+
+/* Barrier implementation because Mac OSX doesn't have pthread_barrier.
+   It also doesn't have clock_gettime(). So much for POSIX and SUSv2.
+   This implementation came from Brent Priddy and was posted on
+   StackOverflow. It is used with his permission. */
+typedef int pthread_barrierattr_t;
+typedef struct pthread_barrier {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int count;
+    int trip_count;
+} pthread_barrier_t;
+
+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)
+{
+	if(count == 0) {
+		errno = EINVAL;
+		return -1;
+	}
+	
+	if(pthread_mutex_init(&barrier->mutex, 0) < 0) {
+		return -1;
+	}
+	if(pthread_cond_init(&barrier->cond, 0) < 0) {
+		pthread_mutex_destroy(&barrier->mutex);
+		return -1;
+	}
+	barrier->trip_count = count;
+	barrier->count = 0;
+
+	return 0;
+}
+
+static int pthread_barrier_destroy(pthread_barrier_t *barrier)
+{
+	pthread_cond_destroy(&barrier->cond);
+	pthread_mutex_destroy(&barrier->mutex);
+	return 0;
+}
+
+static int pthread_barrier_wait(pthread_barrier_t *barrier)
+{
+	pthread_mutex_lock(&barrier->mutex);
+	++(barrier->count);
+	if(barrier->count >= barrier->trip_count)
+	{
+		barrier->count = 0;
+		pthread_cond_broadcast(&barrier->cond);
+		pthread_mutex_unlock(&barrier->mutex);
+		return 1;
+	}
+	else
+	{
+		pthread_cond_wait(&barrier->cond, &(barrier->mutex));
+		pthread_mutex_unlock(&barrier->mutex);
+		return 0;
+	}
+}
+
+static int return_data(hid_device *dev, unsigned char *data, size_t length);
+
+/* Linked List of input reports received from the device. */
+struct input_report {
+	uint8_t *data;
+	size_t len;
+	struct input_report *next;
+};
+
+struct hid_device_ {
+	IOHIDDeviceRef device_handle;
+	int blocking;
+	int uses_numbered_reports;
+	int disconnected;
+	CFStringRef run_loop_mode;
+	CFRunLoopRef run_loop;
+	CFRunLoopSourceRef source;
+	uint8_t *input_report_buf;
+	CFIndex max_input_report_len;
+	struct input_report *input_reports;
+
+	pthread_t thread;
+	pthread_mutex_t mutex; /* Protects input_reports */
+	pthread_cond_t condition;
+	pthread_barrier_t barrier; /* Ensures correct startup sequence */
+	pthread_barrier_t shutdown_barrier; /* Ensures correct shutdown sequence */
+	int shutdown_thread;
+	
+	hid_device *next;
+};
+
+/* Static list of all the devices open. This way when a device gets
+   disconnected, its hid_device structure can be marked as disconnected
+   from hid_device_removal_callback(). */
+static hid_device *device_list = NULL;
+static pthread_mutex_t device_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static hid_device *new_hid_device(void)
+{
+	hid_device *dev = calloc(1, sizeof(hid_device));
+	dev->device_handle = NULL;
+	dev->blocking = 1;
+	dev->uses_numbered_reports = 0;
+	dev->disconnected = 0;
+	dev->run_loop_mode = NULL;
+	dev->run_loop = NULL;
+	dev->source = NULL;
+	dev->input_report_buf = NULL;
+	dev->input_reports = NULL;
+	dev->shutdown_thread = 0;
+	dev->next = NULL;
+
+	/* Thread objects */
+	pthread_mutex_init(&dev->mutex, NULL);
+	pthread_cond_init(&dev->condition, NULL);
+	pthread_barrier_init(&dev->barrier, NULL, 2);
+	pthread_barrier_init(&dev->shutdown_barrier, NULL, 2);
+	
+	/* Add the new record to the device_list. */
+	pthread_mutex_lock(&device_list_mutex);
+	if (!device_list)
+		device_list = dev;
+	else {
+		hid_device *d = device_list;
+		while (d) {
+			if (!d->next) {
+				d->next = dev;
+				break;
+			}
+			d = d->next;
+		}
+	}
+	pthread_mutex_unlock(&device_list_mutex);
+	
+	return dev;
+}
+
+static void free_hid_device(hid_device *dev)
+{
+	if (!dev)
+		return;
+	
+	/* Delete any input reports still left over. */
+	struct input_report *rpt = dev->input_reports;
+	while (rpt) {
+		struct input_report *next = rpt->next;
+		free(rpt->data);
+		free(rpt);
+		rpt = next;
+	}
+
+	/* Free the string and the report buffer. The check for NULL
+	   is necessary here as CFRelease() doesn't handle NULL like
+	   free() and others do. */
+	if (dev->run_loop_mode)
+		CFRelease(dev->run_loop_mode);
+	if (dev->source)
+		CFRelease(dev->source);
+	free(dev->input_report_buf);
+
+	/* Clean up the thread objects */
+	pthread_barrier_destroy(&dev->shutdown_barrier);
+	pthread_barrier_destroy(&dev->barrier);
+	pthread_cond_destroy(&dev->condition);
+	pthread_mutex_destroy(&dev->mutex);
+
+	/* Remove it from the device list. */
+	pthread_mutex_lock(&device_list_mutex);
+	hid_device *d = device_list;
+	if (d == dev) {
+		device_list = d->next;
+	}
+	else {
+		while (d) {
+			if (d->next == dev) {
+				d->next = d->next->next;
+				break;
+			}
+			
+			d = d->next;
+		}
+	}
+	pthread_mutex_unlock(&device_list_mutex);
+
+	/* Free the structure itself. */
+	free(dev);
+}
+
+static 	IOHIDManagerRef hid_mgr = 0x0;
+
+
+#if 0
+static void register_error(hid_device *device, const char *op)
+{
+
+}
+#endif
+
+
+static int32_t get_int_property(IOHIDDeviceRef device, CFStringRef key)
+{
+	CFTypeRef ref;
+	int32_t value;
+	
+	ref = IOHIDDeviceGetProperty(device, key);
+	if (ref) {
+		if (CFGetTypeID(ref) == CFNumberGetTypeID()) {
+			CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, &value);
+			return value;
+		}
+	}
+	return 0;
+}
+
+static unsigned short get_vendor_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDVendorIDKey));
+}
+
+static unsigned short get_product_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDProductIDKey));
+}
+
+
+static int32_t get_max_report_length(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDMaxInputReportSizeKey));
+}
+
+static int get_string_property(IOHIDDeviceRef device, CFStringRef prop, wchar_t *buf, size_t len)
+{
+	CFStringRef str = IOHIDDeviceGetProperty(device, prop);
+
+	buf[0] = 0x0000;
+
+	if (str) {
+		CFRange range;
+		range.location = 0;
+		range.length = len;
+		CFIndex used_buf_len;
+		CFStringGetBytes(str,
+			range,
+			kCFStringEncodingUTF32LE,
+			(char)'?',
+			FALSE,
+			(UInt8*)buf,
+			len,
+			&used_buf_len);
+		buf[len-1] = 0x00000000;
+		return used_buf_len;
+	}
+	else
+		return 0;
+		
+}
+
+static int get_string_property_utf8(IOHIDDeviceRef device, CFStringRef prop, char *buf, size_t len)
+{
+	CFStringRef str = IOHIDDeviceGetProperty(device, prop);
+
+	buf[0] = 0x0000;
+
+	if (str) {
+		CFRange range;
+		range.location = 0;
+		range.length = len;
+		CFIndex used_buf_len;
+		CFStringGetBytes(str,
+			range,
+			kCFStringEncodingUTF8,
+			(char)'?',
+			FALSE,
+			(UInt8*)buf,
+			len,
+			&used_buf_len);
+		buf[len-1] = 0x00000000;
+		return used_buf_len;
+	}
+	else
+		return 0;
+		
+}
+
+
+static int get_serial_number(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDSerialNumberKey), buf, len);
+}
+
+static int get_manufacturer_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDManufacturerKey), buf, len);
+}
+
+static int get_product_string(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDProductKey), buf, len);
+}
+
+
+/* Implementation of wcsdup() for Mac. */
+static wchar_t *dup_wcs(const wchar_t *s)
+{
+	size_t len = wcslen(s);
+	wchar_t *ret = malloc((len+1)*sizeof(wchar_t));
+	wcscpy(ret, s);
+
+	return ret;
+}
+
+
+static int make_path(IOHIDDeviceRef device, char *buf, size_t len)
+{
+	int res;
+	unsigned short vid, pid;
+	char transport[32];
+
+	buf[0] = '\0';
+
+	res = get_string_property_utf8(
+		device, CFSTR(kIOHIDTransportKey),
+		transport, sizeof(transport));
+	
+	if (!res)
+		return -1;
+
+	vid = get_vendor_id(device);
+	pid = get_product_id(device);
+
+	res = snprintf(buf, len, "%s_%04hx_%04hx_%p",
+	                   transport, vid, pid, device);
+	
+	
+	buf[len-1] = '\0';
+	return res+1;
+}
+
+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;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+	if (!hid_mgr) {
+		if (init_hid_manager() < 0) {
+			hid_exit();
+			return -1;
+		}
+	}
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+	if (hid_mgr) {
+		/* Close the HID manager. */
+		IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
+		CFRelease(hid_mgr);
+		hid_mgr = NULL;
+	}
+		
+	return 0;
+}
+
+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
+	struct hid_device_info *cur_dev = NULL;
+	CFIndex num_devices;
+	int i;
+	
+	setlocale(LC_ALL,"");
+
+	/* 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);
+
+	/* Convert the list into a C array so we can iterate easily. */	
+	num_devices = CFSetGetCount(device_set);
+	IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+	CFSetGetValues(device_set, (const void **) device_array);
+
+	/* Iterate over each device, making an entry for it. */	
+	for (i = 0; i < num_devices; i++) {
+		unsigned short dev_vid;
+		unsigned short dev_pid;
+		#define BUF_LEN 256
+		wchar_t buf[BUF_LEN];
+		char cbuf[BUF_LEN];
+
+		IOHIDDeviceRef dev = device_array[i];
+
+        if (!dev) {
+            continue;
+        }
+		dev_vid = get_vendor_id(dev);
+		dev_pid = get_product_id(dev);
+
+		/* 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. */
+			tmp = malloc(sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			cur_dev = tmp;
+
+			// Get the Usage Page and Usage for this device.
+			cur_dev->usage_page = get_int_property(dev, CFSTR(kIOHIDPrimaryUsagePageKey));
+			cur_dev->usage = get_int_property(dev, CFSTR(kIOHIDPrimaryUsageKey));
+
+			/* Fill out the record */
+			cur_dev->next = NULL;
+			len = make_path(dev, cbuf, sizeof(cbuf));
+			cur_dev->path = strdup(cbuf);
+
+			/* Serial Number */
+			get_serial_number(dev, buf, BUF_LEN);
+			cur_dev->serial_number = dup_wcs(buf);
+
+			/* Manufacturer and Product strings */
+			get_manufacturer_string(dev, buf, BUF_LEN);
+			cur_dev->manufacturer_string = dup_wcs(buf);
+			get_product_string(dev, buf, BUF_LEN);
+			cur_dev->product_string = dup_wcs(buf);
+			
+			/* VID/PID */
+			cur_dev->vendor_id = dev_vid;
+			cur_dev->product_id = dev_pid;
+
+			/* Release Number */
+			cur_dev->release_number = get_int_property(dev, CFSTR(kIOHIDVersionNumberKey));
+
+			/* Interface Number (Unsupported on Mac)*/
+			cur_dev->interface_number = -1;
+		}
+	}
+	
+	free(device_array);
+	CFRelease(device_set);
+	
+	return root;
+}
+
+void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
+{
+	/* This function is identical to the Linux version. Platform independent. */
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, wchar_t *serial_number)
+{
+	/* This function is identical to the Linux version. Platform independent. */
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+	hid_device * handle = NULL;
+	
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+	
+	return handle;
+}
+
+static void hid_device_removal_callback(void *context, IOReturn result,
+                                        void *sender, IOHIDDeviceRef dev_ref)
+{
+	/* Stop the Run Loop for this device. */
+	pthread_mutex_lock(&device_list_mutex);
+	hid_device *d = device_list;
+	while (d) {
+		if (d->device_handle == dev_ref) {
+			d->disconnected = 1;
+			CFRunLoopStop(d->run_loop);
+		}
+		
+		d = d->next;
+	}
+	pthread_mutex_unlock(&device_list_mutex);
+}
+
+/* The Run Loop calls this function for each input report received.
+   This function puts the data into a linked list to be picked up by
+   hid_read(). */
+static void hid_report_callback(void *context, IOReturn result, void *sender,
+                         IOHIDReportType report_type, uint32_t report_id,
+                         uint8_t *report, CFIndex report_length)
+{
+	struct input_report *rpt;
+	hid_device *dev = context;
+
+	/* Make a new Input Report object */
+	rpt = calloc(1, sizeof(struct input_report));
+	rpt->data = calloc(1, report_length);
+	memcpy(rpt->data, report, report_length);
+	rpt->len = report_length;
+	rpt->next = NULL;
+
+	/* Lock this section */
+	pthread_mutex_lock(&dev->mutex);
+	
+	/* Attach the new report object to the end of the list. */
+	if (dev->input_reports == NULL) {
+		/* The list is empty. Put it at the root. */
+		dev->input_reports = rpt;
+	}
+	else {
+		/* Find the end of the list and attach. */
+		struct input_report *cur = dev->input_reports;
+		int num_queued = 0;
+		while (cur->next != NULL) {
+			cur = cur->next;
+			num_queued++;
+		}
+		cur->next = rpt;
+
+		/* Pop one off if we've reached 30 in the queue. This
+		   way we don't grow forever if the user never reads
+		   anything from the device. */
+		if (num_queued > 30) {
+			return_data(dev, NULL, 0);
+		}
+	}
+
+	/* Signal a waiting thread that there is data. */
+	pthread_cond_signal(&dev->condition);
+
+	/* Unlock */
+	pthread_mutex_unlock(&dev->mutex);
+
+}
+
+/* This gets called when the read_thred's run loop gets signaled by
+   hid_close(), and serves to stop the read_thread's run loop. */
+static void perform_signal_callback(void *context)
+{
+	hid_device *dev = context;
+	CFRunLoopStop(dev->run_loop); //TODO: CFRunLoopGetCurrent()
+}
+
+static void *read_thread(void *param)
+{
+	hid_device *dev = param;
+	
+	/* Move the device's run loop to this thread. */
+	IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetCurrent(), dev->run_loop_mode);
+
+	/* Create the RunLoopSource which is used to signal the
+	   event loop to stop when hid_close() is called. */
+	CFRunLoopSourceContext ctx;
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.version = 0;
+	ctx.info = dev;
+	ctx.perform = &perform_signal_callback;
+	dev->source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0/*order*/, &ctx);
+	CFRunLoopAddSource(CFRunLoopGetCurrent(), dev->source, dev->run_loop_mode);
+	
+	/* Store off the Run Loop so it can be stopped from hid_close()
+	   and on device disconnection. */
+	dev->run_loop = CFRunLoopGetCurrent();
+
+	/* Notify the main thread that the read thread is up and running. */
+	pthread_barrier_wait(&dev->barrier);
+
+	/* Run the Event Loop. CFRunLoopRunInMode() will dispatch HID input
+	   reports into the hid_report_callback(). */
+	SInt32 code;
+	while (!dev->shutdown_thread && !dev->disconnected) {
+		code = CFRunLoopRunInMode(dev->run_loop_mode, 1000/*sec*/, FALSE);
+		/* Return if the device has been disconnected */
+		if (code == kCFRunLoopRunFinished) {
+			dev->disconnected = 1;
+			break;
+		}
+
+
+		/* Break if The Run Loop returns Finished or Stopped. */
+		if (code != kCFRunLoopRunTimedOut &&
+		    code != kCFRunLoopRunHandledSource) {
+			/* There was some kind of error. Setting
+			   shutdown seems to make sense, but
+			   there may be something else more appropriate */
+			dev->shutdown_thread = 1;
+			break;
+		}
+	}
+
+	/* Now that the read thread is stopping, Wake any threads which are
+	   waiting on data (in hid_read_timeout()). Do this under a mutex to
+	   make sure that a thread which is about to go to sleep waiting on
+	   the condition acutally will go to sleep before the condition is
+	   signaled. */
+	pthread_mutex_lock(&dev->mutex);
+	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. */
+	pthread_barrier_wait(&dev->shutdown_barrier);
+
+	return NULL;
+}
+
+hid_device * HID_API_EXPORT hid_open_path(const char *path)
+{
+  	int i;
+	hid_device *dev = NULL;
+	CFIndex num_devices;
+	
+	dev = new_hid_device();
+
+	/* Set up the HID Manager if it hasn't been done */
+	hid_init();
+
+	CFSetRef device_set = IOHIDManagerCopyDevices(hid_mgr);
+	
+	num_devices = CFSetGetCount(device_set);
+	IOHIDDeviceRef *device_array = calloc(num_devices, sizeof(IOHIDDeviceRef));
+	CFSetGetValues(device_set, (const void **) device_array);	
+	for (i = 0; i < num_devices; i++) {
+		char cbuf[BUF_LEN];
+		size_t len;
+		IOHIDDeviceRef os_dev = device_array[i];
+		
+		len = make_path(os_dev, cbuf, sizeof(cbuf));
+		if (!strcmp(cbuf, path)) {
+			// Matched Paths. Open this Device.
+			IOReturn ret = IOHIDDeviceOpen(os_dev, kIOHIDOptionsTypeNone);
+			if (ret == kIOReturnSuccess) {
+				char str[32];
+
+				free(device_array);
+				CFRelease(device_set);
+				dev->device_handle = os_dev;
+				
+				/* Create the buffers for receiving data */
+				dev->max_input_report_len = (CFIndex) get_max_report_length(os_dev);
+				dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));
+				
+				/* Create the Run Loop Mode for this device.
+				   printing the reference seems to work. */
+				sprintf(str, "HIDAPI_%p", os_dev);
+				dev->run_loop_mode = 
+					CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);
+				
+				/* Attach the device to a Run Loop */
+				IOHIDDeviceRegisterInputReportCallback(
+					os_dev, dev->input_report_buf, dev->max_input_report_len,
+					&hid_report_callback, dev);
+				IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, hid_device_removal_callback, NULL);
+				
+				/* Start the read thread */
+				pthread_create(&dev->thread, NULL, read_thread, dev);
+
+				/* Wait here for the read thread to be initialized. */
+				pthread_barrier_wait(&dev->barrier);
+				
+				return dev;
+			}
+			else {
+				goto return_error;
+			}
+		}
+	}
+
+return_error:
+	free(device_array);
+	CFRelease(device_set);
+	free_hid_device(dev);
+	return NULL;
+}
+
+static int set_report(hid_device *dev, IOHIDReportType type, const unsigned char *data, size_t length)
+{
+	const unsigned char *data_to_send;
+	size_t length_to_send;
+	IOReturn res;
+
+	/* Return if the device has been disconnected. */
+   	if (dev->disconnected)
+   		return -1;
+
+	if (data[0] == 0x0) {
+		/* Not using numbered Reports.
+		   Don't send the report number. */
+		data_to_send = data+1;
+		length_to_send = length-1;
+	}
+	else {
+		/* Using numbered Reports.
+		   Send the Report Number */
+		data_to_send = data;
+		length_to_send = length;
+	}
+	
+	if (!dev->disconnected) {
+		res = IOHIDDeviceSetReport(dev->device_handle,
+					   type,
+					   data[0], /* Report ID*/
+					   data_to_send, length_to_send);
+	
+		if (res == kIOReturnSuccess) {
+			return length;
+		}
+		else
+			return -1;
+	}
+	
+	return -1;
+}
+
+int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	return set_report(dev, kIOHIDReportTypeOutput, data, length);
+}
+
+/* Helper function, so that this isn't duplicated in hid_read(). */
+static int return_data(hid_device *dev, unsigned char *data, size_t length)
+{
+	/* Copy the data out of the linked list item (rpt) into the
+	   return buffer (data), and delete the liked list item. */
+	struct input_report *rpt = dev->input_reports;
+	size_t len = (length < rpt->len)? length: rpt->len;
+	memcpy(data, rpt->data, len);
+	dev->input_reports = rpt->next;
+	free(rpt->data);
+	free(rpt);
+	return len;
+}
+
+static int cond_wait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+	while (!dev->input_reports) {
+		int res = pthread_cond_wait(cond, mutex);
+		if (res != 0)
+			return res;
+
+		/* A res of 0 means we may have been signaled or it may
+		   be a spurious wakeup. Check to see that there's acutally
+		   data in the queue before returning, and if not, go back
+		   to sleep. See the pthread_cond_timedwait() man page for
+		   details. */
+		
+		if (dev->shutdown_thread || dev->disconnected)
+			return -1;
+	}
+	
+	return 0;
+}
+
+static int cond_timedwait(const hid_device *dev, pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
+{
+	while (!dev->input_reports) {
+		int res = pthread_cond_timedwait(cond, mutex, abstime);
+		if (res != 0)
+			return res;
+
+		/* A res of 0 means we may have been signaled or it may
+		   be a spurious wakeup. Check to see that there's acutally
+		   data in the queue before returning, and if not, go back
+		   to sleep. See the pthread_cond_timedwait() man page for
+		   details. */
+		
+		if (dev->shutdown_thread || dev->disconnected)
+			return -1;
+	}
+	
+	return 0;
+
+}
+
+int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	int bytes_read = -1;
+
+	/* Lock the access to the report list. */
+	pthread_mutex_lock(&dev->mutex);
+	
+	/* There's an input report queued up. Return it. */
+	if (dev->input_reports) {
+		/* Return the first one */
+		bytes_read = return_data(dev, data, length);
+		goto ret;
+	}
+
+	/* Return if the device has been disconnected. */
+	if (dev->disconnected) {
+		bytes_read = -1;
+		goto ret;
+	}
+	
+	if (dev->shutdown_thread) {
+		/* This means the device has been closed (or there
+		   has been an error. An error code of -1 should
+		   be returned. */
+		bytes_read = -1;
+		goto ret;
+	}
+
+	/* There is no data. Go to sleep and wait for data. */
+	
+	if (milliseconds == -1) {
+		/* Blocking */
+		int res;
+		res = cond_wait(dev, &dev->condition, &dev->mutex);
+		if (res == 0)
+			bytes_read = return_data(dev, data, length);
+		else {
+			/* There was an error, or a device disconnection. */
+			bytes_read = -1;
+		}
+	}
+	else if (milliseconds > 0) {
+		/* Non-blocking, but called with timeout. */
+		int res;
+		struct timespec ts;
+		struct timeval tv;
+		gettimeofday(&tv, NULL);
+		TIMEVAL_TO_TIMESPEC(&tv, &ts);
+		ts.tv_sec += milliseconds / 1000;
+		ts.tv_nsec += (milliseconds % 1000) * 1000000;
+		if (ts.tv_nsec >= 1000000000L) {
+			ts.tv_sec++;
+			ts.tv_nsec -= 1000000000L;
+		}
+		
+		res = cond_timedwait(dev, &dev->condition, &dev->mutex, &ts);
+		if (res == 0)
+			bytes_read = return_data(dev, data, length);
+		else if (res == ETIMEDOUT)
+			bytes_read = 0;
+		else
+			bytes_read = -1;
+	}
+	else {
+		/* Purely non-blocking */
+		bytes_read = 0;
+	}
+
+ret:
+	/* Unlock */
+	pthread_mutex_unlock(&dev->mutex);
+	return bytes_read;
+}
+
+int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	/* All Nonblocking operation is handled by the library. */
+	dev->blocking = !nonblock;
+	
+	return 0;
+}
+
+int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	return set_report(dev, kIOHIDReportTypeFeature, data, length);
+}
+
+int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	CFIndex len = length;
+	IOReturn res;
+
+	/* Return if the device has been unplugged. */
+	if (dev->disconnected)
+		return -1;
+
+	res = IOHIDDeviceGetReport(dev->device_handle,
+	                           kIOHIDReportTypeFeature,
+	                           data[0], /* Report ID */
+	                           data, &len);
+	if (res == kIOReturnSuccess)
+		return len;
+	else
+		return -1;
+}
+
+
+void HID_API_EXPORT hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+
+	/* Disconnect the report callback before close. */
+	if (!dev->disconnected) {
+		IOHIDDeviceRegisterInputReportCallback(
+			dev->device_handle, dev->input_report_buf, dev->max_input_report_len,
+			NULL, dev);
+		IOHIDManagerRegisterDeviceRemovalCallback(hid_mgr, NULL, dev);
+		IOHIDDeviceUnscheduleFromRunLoop(dev->device_handle, dev->run_loop, dev->run_loop_mode);
+		IOHIDDeviceScheduleWithRunLoop(dev->device_handle, CFRunLoopGetMain(), kCFRunLoopDefaultMode);
+	}
+	
+	/* Cause read_thread() to stop. */
+	dev->shutdown_thread = 1;
+	
+	/* Wake up the run thread's event loop so that the thread can exit. */
+	CFRunLoopSourceSignal(dev->source);
+	CFRunLoopWakeUp(dev->run_loop);
+	
+	/* Notify the read thread that it can shut down now. */
+	pthread_barrier_wait(&dev->shutdown_barrier);
+
+	/* Wait for read_thread() to end. */
+	pthread_join(dev->thread, NULL);
+
+	/* 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);
+	}
+	
+	/* Clear out the queue of received reports. */
+	pthread_mutex_lock(&dev->mutex);
+	while (dev->input_reports) {
+		return_data(dev, NULL, 0);
+	}
+	pthread_mutex_unlock(&dev->mutex);
+
+	free_hid_device(dev);
+}
+
+int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_manufacturer_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_product_string(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	return get_serial_number(dev->device_handle, string, maxlen);
+}
+
+int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	// TODO:
+
+	return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	// TODO:
+
+	return NULL;
+}
+
+
+
+
+
+
+#if 0
+static int32_t get_location_id(IOHIDDeviceRef device)
+{
+	return get_int_property(device, CFSTR(kIOHIDLocationIDKey));
+}
+
+static int32_t get_usage(IOHIDDeviceRef device)
+{
+	int32_t res;
+	res = get_int_property(device, CFSTR(kIOHIDDeviceUsageKey));
+	if (!res)
+		res = get_int_property(device, CFSTR(kIOHIDPrimaryUsageKey));
+	return res;
+}
+
+static int32_t get_usage_page(IOHIDDeviceRef device)
+{
+	int32_t res;
+	res = get_int_property(device, CFSTR(kIOHIDDeviceUsagePageKey));
+	if (!res)
+		res = get_int_property(device, CFSTR(kIOHIDPrimaryUsagePageKey));
+	return res;
+}
+
+static int get_transport(IOHIDDeviceRef device, wchar_t *buf, size_t len)
+{
+	return get_string_property(device, CFSTR(kIOHIDTransportKey), buf, len);
+}
+
+
+int main(void)
+{
+	IOHIDManagerRef mgr;
+	int i;
+	
+	mgr = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+	IOHIDManagerSetDeviceMatching(mgr, NULL);
+	IOHIDManagerOpen(mgr, kIOHIDOptionsTypeNone);
+	
+	CFSetRef device_set = IOHIDManagerCopyDevices(mgr);
+	
+	CFIndex num_devices = CFSetGetCount(device_set);
+	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);
+		printf("  %04hx %04hx\n", get_vendor_id(dev), get_product_id(dev));
+
+		wchar_t serial[256], buf[256];
+		char cbuf[256];
+		get_serial_number(dev, serial, 256);
+
+		
+		printf("  Serial: %ls\n", serial);
+		printf("  Loc: %ld\n", get_location_id(dev));
+		get_transport(dev, buf, 256);
+		printf("  Trans: %ls\n", buf);
+		make_path(dev, cbuf, 256);
+		printf("  Path: %s\n", cbuf);
+		
+	}
+	
+	return 0;
+}
+#endif

=== added directory 'mixxx/lib/hidapi-0.7.0/windows'
=== added file 'mixxx/lib/hidapi-0.7.0/windows/.gitignore'
--- mixxx/lib/hidapi-0.7.0/windows/.gitignore	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/.gitignore	2012-04-07 14:24:23 +0000
@@ -0,0 +1,11 @@
+Debug
+Release
+*.exp
+*.ilk
+*.lib
+*.suo
+*.vcproj.*
+*.ncb
+*.suo
+*.dll
+*.pdb

=== added file 'mixxx/lib/hidapi-0.7.0/windows/Makefile'
--- mixxx/lib/hidapi-0.7.0/windows/Makefile	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/Makefile	2012-04-07 14:24:23 +0000
@@ -0,0 +1,14 @@
+
+
+OS=$(shell uname)
+
+ifneq (,$(findstring MINGW,$(OS)))
+	FILE=Makefile.mingw
+endif
+
+ifeq ($(FILE), )
+all:
+	$(error Your platform ${OS} is not supported at this time.)
+endif
+
+include $(FILE)

=== added file 'mixxx/lib/hidapi-0.7.0/windows/Makefile.mingw'
--- mixxx/lib/hidapi-0.7.0/windows/Makefile.mingw	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/Makefile.mingw	2012-04-07 14:24:23 +0000
@@ -0,0 +1,32 @@
+###########################################
+# Simple Makefile for HIDAPI test program
+#
+# Alan Ott
+# Signal 11 Software
+# 2010-06-01
+###########################################
+
+all: hidtest
+
+CC=gcc
+CXX=g++
+COBJS=hid.o
+CPPOBJS=../hidtest/hidtest.o
+OBJS=$(COBJS) $(CPPOBJS)
+CFLAGS=-I../hidapi -g -c
+LIBS= -lsetupapi
+
+
+hidtest: $(OBJS)
+	g++ -g $^ $(LIBS) -o hidtest
+
+$(COBJS): %.o: %.c
+	$(CC) $(CFLAGS) $< -o $@
+
+$(CPPOBJS): %.o: %.cpp
+	$(CXX) $(CFLAGS) $< -o $@
+
+clean:
+	rm *.o ../hidtest/*.o hidtest.exe
+
+.PHONY: clean

=== added directory 'mixxx/lib/hidapi-0.7.0/windows/ddk_build'
=== added file 'mixxx/lib/hidapi-0.7.0/windows/ddk_build/.gitignore'
--- mixxx/lib/hidapi-0.7.0/windows/ddk_build/.gitignore	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/ddk_build/.gitignore	2012-04-07 14:24:23 +0000
@@ -0,0 +1,2 @@
+*.log
+obj*_*_*
\ No newline at end of file

=== added file 'mixxx/lib/hidapi-0.7.0/windows/ddk_build/hidapi.def'
--- mixxx/lib/hidapi-0.7.0/windows/ddk_build/hidapi.def	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/ddk_build/hidapi.def	2012-04-07 14:24:23 +0000
@@ -0,0 +1,17 @@
+LIBRARY   hidapi
+EXPORTS
+   hid_open    @1
+   hid_write   @2
+   hid_read    @3
+   hid_close   @4
+   hid_get_product_string @5
+   hid_get_manufacturer_string @6
+   hid_get_serial_number_string @7
+   hid_get_indexed_string @8
+   hid_error @9
+   hid_set_nonblocking @10
+   hid_enumerate @11
+   hid_open_path @12
+   hid_send_feature_report @13
+   hid_get_feature_report @14
+   
\ No newline at end of file

=== added file 'mixxx/lib/hidapi-0.7.0/windows/ddk_build/makefile'
--- mixxx/lib/hidapi-0.7.0/windows/ddk_build/makefile	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/ddk_build/makefile	2012-04-07 14:24:23 +0000
@@ -0,0 +1,49 @@
+#############################################################################
+#
+#               Copyright (C) Microsoft Corporation 1995, 1996
+#       All Rights Reserved.
+#
+#       MAKEFILE for HID directory
+#
+#############################################################################
+
+!IFDEF WIN95_BUILD
+
+ROOT=..\..\..\..
+
+VERSIONLIST = debug retail
+IS_32 = TRUE
+IS_SDK = TRUE
+IS_PRIVATE = TRUE
+IS_SDK = TRUE
+IS_DDK = TRUE
+WIN32 = TRUE
+COMMONMKFILE = hidapi.mk
+
+!include $(ROOT)\dev\master.mk
+
+
+!ELSE
+
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the driver components of the Windows NT DDK
+#
+
+!IF DEFINED(_NT_TARGET_VERSION)
+!	IF $(_NT_TARGET_VERSION)>=0x501
+!		INCLUDE $(NTMAKEENV)\makefile.def
+!	ELSE
+#               Only warn once per directory
+!               INCLUDE $(NTMAKEENV)\makefile.plt
+!               IF "$(BUILD_PASS)"=="PASS1"
+!		    message BUILDMSG: Warning : The sample "$(MAKEDIR)" is not valid for the current OS target.
+!               ENDIF
+!	ENDIF
+!ELSE
+!	INCLUDE $(NTMAKEENV)\makefile.def
+!ENDIF
+
+!ENDIF
+

=== added file 'mixxx/lib/hidapi-0.7.0/windows/ddk_build/sources'
--- mixxx/lib/hidapi-0.7.0/windows/ddk_build/sources	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/ddk_build/sources	2012-04-07 14:24:23 +0000
@@ -0,0 +1,23 @@
+TARGETNAME=hidapi
+TARGETTYPE=DYNLINK
+UMTYPE=console
+UMENTRY=main
+
+MSC_WARNING_LEVEL=/W3 /WX
+
+TARGETLIBS=$(SDK_LIB_PATH)\hid.lib \
+           $(SDK_LIB_PATH)\setupapi.lib \
+           $(SDK_LIB_PATH)\kernel32.lib \
+           $(SDK_LIB_PATH)\comdlg32.lib
+
+USE_MSVCRT=1
+
+INCLUDES= ..\..\hidapi
+SOURCES= ..\hid.c \
+
+
+TARGET_DESTINATION=retail
+
+MUI=0
+MUI_COMMENT="HID Interface DLL"
+

=== added file 'mixxx/lib/hidapi-0.7.0/windows/hid.c'
--- mixxx/lib/hidapi-0.7.0/windows/hid.c	1970-01-01 00:00:00 +0000
+++ mixxx/lib/hidapi-0.7.0/windows/hid.c	2012-04-07 14:24:23 +0000
@@ -0,0 +1,873 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+ 
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+#include <windows.h>
+
+#ifndef _NTDEF_
+typedef LONG NTSTATUS;
+#endif
+
+#ifdef __MINGW32__
+#include <ntdef.h>
+#include <winbase.h>
+#endif
+
+#ifdef __CYGWIN__
+#include <ntdef.h>
+#define _wcsdup wcsdup
+#endif
+
+//#define HIDAPI_USE_DDK
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	#include <setupapi.h>
+	#include <winioctl.h>
+	#ifdef HIDAPI_USE_DDK
+		#include <hidsdi.h>
+	#endif
+
+	// Copied from inc/ddk/hidclass.h, part of the Windows DDK.
+	#define HID_OUT_CTL_CODE(id)  \
+		CTL_CODE(FILE_DEVICE_KEYBOARD, (id), METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+	#define IOCTL_HID_GET_FEATURE                   HID_OUT_CTL_CODE(100)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include "hidapi.h"
+
+#ifdef _MSC_VER
+	// Thanks Microsoft, but I know how to use strncpy().
+	#pragma warning(disable:4996)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef HIDAPI_USE_DDK
+	// Since we're not building with the DDK, and the HID header
+	// files aren't part of the SDK, we have to define all this
+	// stuff here. In lookup_functions(), the function pointers
+	// defined below are set.
+	typedef struct _HIDD_ATTRIBUTES{
+		ULONG Size;
+		USHORT VendorID;
+		USHORT ProductID;
+		USHORT VersionNumber;
+	} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+	typedef USHORT USAGE;
+	typedef struct _HIDP_CAPS {
+		USAGE Usage;
+		USAGE UsagePage;
+		USHORT InputReportByteLength;
+		USHORT OutputReportByteLength;
+		USHORT FeatureReportByteLength;
+		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 BOOLEAN (__stdcall *HidD_GetAttributes_)(HANDLE device, PHIDD_ATTRIBUTES attrib);
+	typedef BOOLEAN (__stdcall *HidD_GetSerialNumberString_)(HANDLE device, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_GetManufacturerString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+	typedef BOOLEAN (__stdcall *HidD_GetProductString_)(HANDLE handle, PVOID buffer, ULONG buffer_len);
+	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);
+
+	static HidD_GetAttributes_ HidD_GetAttributes;
+	static HidD_GetSerialNumberString_ HidD_GetSerialNumberString;
+	static HidD_GetManufacturerString_ HidD_GetManufacturerString;
+	static HidD_GetProductString_ HidD_GetProductString;
+	static HidD_SetFeature_ HidD_SetFeature;
+	static HidD_GetFeature_ HidD_GetFeature;
+	static HidD_GetIndexedString_ HidD_GetIndexedString;
+	static HidD_GetPreparsedData_ HidD_GetPreparsedData;
+	static HidD_FreePreparsedData_ HidD_FreePreparsedData;
+	static HidP_GetCaps_ HidP_GetCaps;
+
+	static HMODULE lib_handle = NULL;
+	static BOOLEAN initialized = FALSE;
+#endif // HIDAPI_USE_DDK
+
+struct hid_device_ {
+		HANDLE device_handle;
+		BOOL blocking;
+		size_t input_report_length;
+		void *last_error_str;
+		DWORD last_error_num;
+		BOOL read_pending;
+		char *read_buf;
+		OVERLAPPED ol;
+};
+
+static hid_device *new_hid_device()
+{
+	hid_device *dev = (hid_device*) calloc(1, sizeof(hid_device));
+	dev->device_handle = INVALID_HANDLE_VALUE;
+	dev->blocking = TRUE;
+	dev->input_report_length = 0;
+	dev->last_error_str = NULL;
+	dev->last_error_num = 0;
+	dev->read_pending = FALSE;
+	dev->read_buf = NULL;
+	memset(&dev->ol, 0, sizeof(dev->ol));
+	dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*inital state f=nonsignaled*/, NULL);
+
+	return dev;
+}
+
+
+static void register_error(hid_device *device, const char *op)
+{
+	WCHAR *ptr, *msg;
+
+	FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+		FORMAT_MESSAGE_FROM_SYSTEM |
+		FORMAT_MESSAGE_IGNORE_INSERTS,
+		NULL,
+		GetLastError(),
+		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		(LPWSTR)&msg, 0/*sz*/,
+		NULL);
+	
+	// Get rid of the CR and LF that FormatMessage() sticks at the
+	// end of the message. Thanks Microsoft!
+	ptr = msg;
+	while (*ptr) {
+		if (*ptr == '\r') {
+			*ptr = 0x0000;
+			break;
+		}
+		ptr++;
+	}
+
+	// Store the message off in the Device entry so that 
+	// the hid_error() function can pick it up.
+	LocalFree(device->last_error_str);
+	device->last_error_str = msg;
+}
+
+#ifndef HIDAPI_USE_DDK
+static int lookup_functions()
+{
+	lib_handle = LoadLibraryA("hid.dll");
+	if (lib_handle) {
+#define RESOLVE(x) x = (x##_)GetProcAddress(lib_handle, #x); if (!x) return -1;
+		RESOLVE(HidD_GetAttributes);
+		RESOLVE(HidD_GetSerialNumberString);
+		RESOLVE(HidD_GetManufacturerString);
+		RESOLVE(HidD_GetProductString);
+		RESOLVE(HidD_SetFeature);
+		RESOLVE(HidD_GetFeature);
+		RESOLVE(HidD_GetIndexedString);
+		RESOLVE(HidD_GetPreparsedData);
+		RESOLVE(HidD_FreePreparsedData);
+		RESOLVE(HidP_GetCaps);
+#undef RESOLVE
+	}
+	else
+		return -1;
+
+	return 0;
+}
+#endif
+
+static HANDLE open_device(const char *path)
+{
+	HANDLE handle;
+
+	/* 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*/
+		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;
+}
+
+int HID_API_EXPORT hid_init(void)
+{
+#ifndef HIDAPI_USE_DDK
+	if (!initialized) {
+		if (lookup_functions() < 0) {
+			hid_exit();
+			return -1;
+		}
+		initialized = TRUE;
+	}
+#endif
+	return 0;
+}
+
+int HID_API_EXPORT hid_exit(void)
+{
+#ifndef HIDAPI_USE_DDK
+	if (lib_handle)
+		FreeLibrary(lib_handle);
+	lib_handle = NULL;
+	initialized = FALSE;
+#endif
+	return 0;
+}
+
+struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
+{
+	BOOL res;
+	struct hid_device_info *root = NULL; // return object
+	struct hid_device_info *cur_dev = NULL;
+
+	// Windows objects for interacting with the driver.
+	GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, {0x88, 0xcb, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30} };
+	SP_DEVINFO_DATA devinfo_data;
+	SP_DEVICE_INTERFACE_DATA device_interface_data;
+	SP_DEVICE_INTERFACE_DETAIL_DATA_A *device_interface_detail_data = NULL;
+	HDEVINFO device_info_set = INVALID_HANDLE_VALUE;
+	int device_index = 0;
+
+	if (hid_init() < 0)
+		return NULL;
+
+	// Initialize the Windows objects.
+	devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
+	device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+
+	// Get information for all the devices belonging to the HID class.
+	device_info_set = SetupDiGetClassDevsA(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+	
+	// Iterate over each device in the HID class, looking for the right one.
+	
+	for (;;) {
+		HANDLE write_handle = INVALID_HANDLE_VALUE;
+		DWORD required_size = 0;
+		HIDD_ATTRIBUTES attrib;
+
+		res = SetupDiEnumDeviceInterfaces(device_info_set,
+			NULL,
+			&InterfaceClassGuid,
+			device_index,
+			&device_interface_data);
+		
+		if (!res) {
+			// A return of FALSE from this function means that
+			// there are no more devices.
+			break;
+		}
+
+		// Call with 0-sized detail size, and let the function
+		// tell us how long the detail struct needs to be. The
+		// size is put in &required_size.
+		res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+			&device_interface_data,
+			NULL,
+			0,
+			&required_size,
+			NULL);
+
+		// Allocate a long enough structure for device_interface_detail_data.
+		device_interface_detail_data = (SP_DEVICE_INTERFACE_DETAIL_DATA_A*) malloc(required_size);
+		device_interface_detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
+
+		// Get the detailed data for this device. The detail data gives us
+		// the device path for this device, which is then passed into
+		// CreateFile() to get a handle to the device.
+		res = SetupDiGetDeviceInterfaceDetailA(device_info_set,
+			&device_interface_data,
+			device_interface_detail_data,
+			required_size,
+			NULL,
+			NULL);
+
+		if (!res) {
+			//register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");
+			// Continue to the next device.
+			goto cont;
+		}
+
+		//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);
+
+		// Check validity of write_handle.
+		if (write_handle == INVALID_HANDLE_VALUE) {
+			// Unable to open the device.
+			//register_error(dev, "CreateFile");
+			goto cont_close;
+		}		
+
+
+		// Get the Vendor ID and Product ID for this device.
+		attrib.Size = sizeof(HIDD_ATTRIBUTES);
+		HidD_GetAttributes(write_handle, &attrib);
+		//wprintf(L"Product/Vendor: %x %x\n", attrib.ProductID, attrib.VendorID);
+
+		// Check the VID/PID to see if we should add this
+		// device to the enumeration list.
+		if ((vendor_id == 0x0 && product_id == 0x0) || 
+			(attrib.VendorID == vendor_id && attrib.ProductID == product_id)) {
+
+			#define WSTR_LEN 512
+			const char *str;
+			struct hid_device_info *tmp;
+			HIDP_PREPARSED_DATA *pp_data = NULL;
+			HIDP_CAPS caps;
+			BOOLEAN res;
+			NTSTATUS nt_res;
+			wchar_t wstr[WSTR_LEN]; // TODO: Determine Size
+			size_t len;
+
+			/* VID/PID match. Create the record. */
+			tmp = (struct hid_device_info*) calloc(1, sizeof(struct hid_device_info));
+			if (cur_dev) {
+				cur_dev->next = tmp;
+			}
+			else {
+				root = tmp;
+			}
+			cur_dev = tmp;
+
+			// Get the Usage Page and Usage for this device.
+			res = HidD_GetPreparsedData(write_handle, &pp_data);
+			if (res) {
+				nt_res = HidP_GetCaps(pp_data, &caps);
+				if (nt_res == HIDP_STATUS_SUCCESS) {
+					cur_dev->usage_page = caps.UsagePage;
+					cur_dev->usage = caps.Usage;
+				}
+
+				HidD_FreePreparsedData(pp_data);
+			}
+			
+			/* Fill out the record */
+			cur_dev->next = NULL;
+			str = device_interface_detail_data->DevicePath;
+			if (str) {
+				len = strlen(str);
+				cur_dev->path = (char*) calloc(len+1, sizeof(char));
+				strncpy(cur_dev->path, str, len+1);
+				cur_dev->path[len] = '\0';
+			}
+			else
+				cur_dev->path = NULL;
+
+			/* Serial Number */
+			res = HidD_GetSerialNumberString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->serial_number = _wcsdup(wstr);
+			}
+
+			/* Manufacturer String */
+			res = HidD_GetManufacturerString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->manufacturer_string = _wcsdup(wstr);
+			}
+
+			/* Product String */
+			res = HidD_GetProductString(write_handle, wstr, sizeof(wstr));
+			wstr[WSTR_LEN-1] = 0x0000;
+			if (res) {
+				cur_dev->product_string = _wcsdup(wstr);
+			}
+
+			/* VID/PID */
+			cur_dev->vendor_id = attrib.VendorID;
+			cur_dev->product_id = attrib.ProductID;
+
+			/* Release Number */
+			cur_dev->release_number = attrib.VersionNumber;
+
+			/* Interface Number. It can sometimes be parsed out of the path
+			   on Windows if a device has multiple interfaces. See
+			   http://msdn.microsoft.com/en-us/windows/hardware/gg487473 or
+			   search for "Hardware IDs for HID Devices" at MSDN. If it's not
+			   in the path, it's set to -1. */
+			cur_dev->interface_number = -1;
+			if (cur_dev->path) {
+				char *interface_component = strstr(cur_dev->path, "&mi_");
+				if (interface_component) {
+					char *hex_str = interface_component + 4;
+					char *endptr = NULL;
+					cur_dev->interface_number = strtol(hex_str, &endptr, 16);
+					if (endptr == hex_str) {
+						/* The parsing failed. Set interface_number to -1. */
+						cur_dev->interface_number = -1;
+					}
+				}
+			}
+		}
+
+cont_close:
+		CloseHandle(write_handle);
+cont:
+		// We no longer need the detail data. It can be freed
+		free(device_interface_detail_data);
+
+		device_index++;
+
+	}
+
+	// Close the device information handle.
+	SetupDiDestroyDeviceInfoList(device_info_set);
+
+	return root;
+
+}
+
+void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
+{
+	// TODO: Merge this with the Linux version. This function is platform-independent.
+	struct hid_device_info *d = devs;
+	while (d) {
+		struct hid_device_info *next = d->next;
+		free(d->path);
+		free(d->serial_number);
+		free(d->manufacturer_string);
+		free(d->product_string);
+		free(d);
+		d = next;
+	}
+}
+
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, 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;
+	const char *path_to_open = NULL;
+	hid_device *handle = NULL;
+	
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+		    cur_dev->product_id == product_id) {
+			if (serial_number) {
+				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
+					path_to_open = cur_dev->path;
+					break;
+				}
+			}
+			else {
+				path_to_open = cur_dev->path;
+				break;
+			}
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	if (path_to_open) {
+		/* Open the device */
+		handle = hid_open_path(path_to_open);
+	}
+
+	hid_free_enumeration(devs);
+	
+	return handle;
+}
+
+HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path)
+{
+	hid_device *dev;
+	HIDP_CAPS caps;
+	HIDP_PREPARSED_DATA *pp_data = NULL;
+	BOOLEAN res;
+	NTSTATUS nt_res;
+
+	if (hid_init() < 0) {
+		return NULL;
+	}
+
+	dev = new_hid_device();
+
+	// Open a handle to the device
+	dev->device_handle = open_device(path);
+
+	// Check validity of write_handle.
+	if (dev->device_handle == INVALID_HANDLE_VALUE) {
+		// Unable to open the device.
+		register_error(dev, "CreateFile");
+		goto err;
+	}
+
+	// Get the Input Report length for the device.
+	res = HidD_GetPreparsedData(dev->device_handle, &pp_data);
+	if (!res) {
+		register_error(dev, "HidD_GetPreparsedData");
+		goto err;
+	}
+	nt_res = HidP_GetCaps(pp_data, &caps);
+	if (nt_res != HIDP_STATUS_SUCCESS) {
+		register_error(dev, "HidP_GetCaps");	
+		goto err_pp_data;
+	}
+	dev->input_report_length = caps.InputReportByteLength;
+	HidD_FreePreparsedData(pp_data);
+
+	dev->read_buf = (char*) malloc(dev->input_report_length);
+
+	return dev;
+
+err_pp_data:
+		HidD_FreePreparsedData(pp_data);
+err:	
+		CloseHandle(dev->device_handle);
+		free(dev);
+		return NULL;
+}
+
+int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length)
+{
+	DWORD bytes_written;
+	BOOL res;
+
+	OVERLAPPED ol;
+	memset(&ol, 0, sizeof(ol));
+
+	res = WriteFile(dev->device_handle, data, length, NULL, &ol);
+	
+	if (!res) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			// WriteFile() failed. Return error.
+			register_error(dev, "WriteFile");
+			return -1;
+		}
+	}
+
+	// Wait here until the write is done. This makes
+	// hid_write() synchronous.
+	res = GetOverlappedResult(dev->device_handle, &ol, &bytes_written, TRUE/*wait*/);
+	if (!res) {
+		// The Write operation failed.
+		register_error(dev, "WriteFile");
+		return -1;
+	}
+
+	return bytes_written;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
+{
+	DWORD bytes_read = 0;
+	BOOL res;
+
+	// Copy the handle for convenience.
+	HANDLE ev = dev->ol.hEvent;
+
+	if (!dev->read_pending) {
+		// Start an Overlapped I/O read.
+		dev->read_pending = TRUE;
+		ResetEvent(ev);
+		res = ReadFile(dev->device_handle, dev->read_buf, dev->input_report_length, &bytes_read, &dev->ol);
+		
+		if (!res) {
+			if (GetLastError() != ERROR_IO_PENDING) {
+				// ReadFile() has failed.
+				// Clean up and return error.
+				CancelIo(dev->device_handle);
+				dev->read_pending = FALSE;
+				goto end_of_function;
+			}
+		}
+	}
+
+	if (milliseconds >= 0) {
+		// See if there is any data yet.
+		res = WaitForSingleObject(ev, milliseconds);
+		if (res != WAIT_OBJECT_0) {
+			// There was no data this time. Return zero bytes available,
+			// but leave the Overlapped I/O running.
+			return 0;
+		}
+	}
+
+	// Either WaitForSingleObject() told us that ReadFile has completed, or
+	// we are in non-blocking mode. Get the number of bytes read. The actual
+	// data has been copied to the data[] array which was passed to ReadFile().
+	res = GetOverlappedResult(dev->device_handle, &dev->ol, &bytes_read, TRUE/*wait*/);
+	
+	// Set pending back to false, even if GetOverlappedResult() returned error.
+	dev->read_pending = FALSE;
+
+	if (res && bytes_read > 0) {
+		if (dev->read_buf[0] == 0x0) {
+			/* If report numbers aren't being used, but Windows sticks a report
+			   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. */
+			bytes_read--;
+			memcpy(data, dev->read_buf+1, length);
+		}
+		else {
+			/* Copy the whole buffer, report number and all. */
+			memcpy(data, dev->read_buf, length);
+		}
+	}
+	
+end_of_function:
+	if (!res) {
+		register_error(dev, "GetOverlappedResult");
+		return -1;
+	}
+	
+	return bytes_read;
+}
+
+int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length)
+{
+	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
+}
+
+int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock)
+{
+	dev->blocking = !nonblock;
+	return 0; /* Success */
+}
+
+int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
+{
+	BOOL res = HidD_SetFeature(dev->device_handle, (PVOID)data, length);
+	if (!res) {
+		register_error(dev, "HidD_SetFeature");
+		return -1;
+	}
+
+	return length;
+}
+
+
+int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
+{
+	BOOL res;
+#if 0
+	res = HidD_GetFeature(dev->device_handle, data, length);
+	if (!res) {
+		register_error(dev, "HidD_GetFeature");
+		return -1;
+	}
+	return 0; /* HidD_GetFeature() doesn't give us an actual length, unfortunately */
+#else
+	DWORD bytes_returned;
+
+	OVERLAPPED ol;
+	memset(&ol, 0, sizeof(ol));
+
+	res = DeviceIoControl(dev->device_handle,
+		IOCTL_HID_GET_FEATURE,
+		data, length,
+		data, length,
+		&bytes_returned, &ol);
+
+	if (!res) {
+		if (GetLastError() != ERROR_IO_PENDING) {
+			// DeviceIoControl() failed. Return error.
+			register_error(dev, "Send Feature Report DeviceIoControl");
+			return -1;
+		}
+	}
+
+	// Wait here until the write is done. This makes
+	// hid_get_feature_report() synchronous.
+	res = GetOverlappedResult(dev->device_handle, &ol, &bytes_returned, TRUE/*wait*/);
+	if (!res) {
+		// The operation failed.
+		register_error(dev, "Send Feature Report GetOverLappedResult");
+		return -1;
+	}
+	return bytes_returned;
+#endif
+}
+
+void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev)
+{
+	if (!dev)
+		return;
+	CancelIo(dev->device_handle);
+	CloseHandle(dev->ol.hEvent);
+	CloseHandle(dev->device_handle);
+	LocalFree(dev->last_error_str);
+	free(dev->read_buf);
+	free(dev);
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetManufacturerString(dev->device_handle, string, 2 * maxlen);
+	if (!res) {
+		register_error(dev, "HidD_GetManufacturerString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetProductString(dev->device_handle, string, 2 * maxlen);
+	if (!res) {
+		register_error(dev, "HidD_GetProductString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetSerialNumberString(dev->device_handle, string, 2 * maxlen);
+	if (!res) {
+		register_error(dev, "HidD_GetSerialNumberString");
+		return -1;
+	}
+
+	return 0;
+}
+
+int HID_API_EXPORT_CALL HID_API_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
+{
+	BOOL res;
+
+	res = HidD_GetIndexedString(dev->device_handle, string_index, string, 2 * maxlen);
+	if (!res) {
+		register_error(dev, "HidD_GetIndexedString");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
+{
+	return (wchar_t*)dev->last_error_str;
+}
+
+
+//#define PICPGM
+//#define S11
+#define P32
+#ifdef S11 
+  unsigned short VendorID = 0xa0a0;
+	unsigned short ProductID = 0x0001;
+#endif
+
+#ifdef P32
+  unsigned short VendorID = 0x04d8;
+	unsigned short ProductID = 0x3f;
+#endif
+
+
+#ifdef PICPGM
+  unsigned short VendorID = 0x04d8;
+  unsigned short ProductID = 0x0033;
+#endif
+
+
+#if 0
+int __cdecl main(int argc, char* argv[])
+{
+	int res;
+	unsigned char buf[65];
+
+	UNREFERENCED_PARAMETER(argc);
+	UNREFERENCED_PARAMETER(argv);
+
+	// Set up the command buffer.
+	memset(buf,0x00,sizeof(buf));
+	buf[0] = 0;
+	buf[1] = 0x81;
+	
+
+	// Open the device.
+	int handle = open(VendorID, ProductID, L"12345");
+	if (handle < 0)
+		printf("unable to open device\n");
+
+
+	// Toggle LED (cmd 0x80)
+	buf[1] = 0x80;
+	res = write(handle, buf, 65);
+	if (res < 0)
+		printf("Unable to write()\n");
+
+	// Request state (cmd 0x81)
+	buf[1] = 0x81;
+	write(handle, buf, 65);
+	if (res < 0)
+		printf("Unable to write() (2)\n");
+