Merge lp:~neale/mixxx/usbbulk into lp:~mixxxdevelopers/mixxx/trunk

[Neale Pickett]

USB bulk driver, makes Hercules controllers work without a driver. Still has shutdown issues, but it works fine until you close mixxx. Linux users like me are in dire need of this.

Should be tested with non-Herc controllers to make sure the shutdown problem doesn't affect other USB devices.

=== modified file 'mixxx/SConstruct'
--- mixxx/SConstruct	2012-04-25 15:40:15 +0000
+++ mixxx/SConstruct	2012-08-25 14:32:20 +0000
@@ -38,6 +38,7 @@
                       features.MediaFoundation,
                       features.HSS1394,
                       features.HID,
+                      features.Bulk,
                       features.VinylControl,
                       features.Shoutcast,
                       features.Profiling,

=== modified file 'mixxx/build/features.py'
--- mixxx/build/features.py	2012-07-08 07:30:32 +0000
+++ mixxx/build/features.py	2012-08-25 14:32:20 +0000
@@ -105,6 +105,37 @@
             sources.append(os.path.join(self.HIDAPI_INTERNAL_PATH, 'mac/hid.c'))
         return sources
 
+class Bulk(Feature):
+    def description(self):
+        return "USB Bulk controller support"
+
+    def enabled(self, build):
+        build.flags['bulk'] = util.get_flags(build.env, 'bulk', 1)
+        if int(build.flags['bulk']):
+            return True
+        return False
+
+    def add_options(self, build, vars):
+        vars.Add('bulk', 'Set to 1 to enable USB Bulk controller support.', 1)
+
+    def configure(self, build, conf):
+        if not self.enabled(build):
+            return
+
+        build.env.ParseConfig('pkg-config libusb-1.0 --silence-errors --cflags --libs')
+        if (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!')
+
+        build.env.Append(CPPDEFINES = '__BULK__')
+
+    def sources(self, build):
+        sources = ['controllers/bulk/bulkcontroller.cpp',
+                   'controllers/bulk/bulkenumerator.cpp']
+
+        return sources
+
+
 class Mad(Feature):
     def description(self):
         return "MAD MP3 Decoder"

=== modified file 'mixxx/plugins/soundsourcem4a/m4a/mp4-mixxx.cpp'
--- mixxx/plugins/soundsourcem4a/m4a/mp4-mixxx.cpp	2012-05-04 03:44:44 +0000
+++ mixxx/plugins/soundsourcem4a/m4a/mp4-mixxx.cpp	2012-08-25 14:32:20 +0000
@@ -145,7 +145,7 @@
     priv->overflow_buf_len = 0;
     priv->overflow_buf = NULL;
 
-    priv->sample_buf_len = 4096;
+    priv->sample_buf_len = 8192;
     priv->sample_buf = new char[priv->sample_buf_len];
     priv->sample_buf_frame = -1;
 
@@ -185,6 +185,8 @@
     priv->aac_data_len = MP4GetTrackMaxSampleSize(priv->mp4.handle, priv->mp4.track);
     priv->aac_data = new unsigned char[priv->aac_data_len];
 
+    qDebug() << "AAC Data Length:" << priv->aac_data_len;
+
     priv->mp4.num_samples = MP4GetTrackNumberOfSamples(priv->mp4.handle, priv->mp4.track);
     // MP4 frames are 1-indexed
     priv->mp4.sample = 1;
@@ -335,6 +337,7 @@
     bytes = frame_info.samples * 2;
 
     if (bytes > count) {
+      qDebug() << "TOO MUCH BABY!  " << bytes << ":" << count;
         /* decoded too much; keep overflow. */
         //memcpy(priv->overflow_buf_base, sample_buf + count, bytes - count);
         //priv->overflow_buf = priv->overflow_buf_base;
@@ -358,6 +361,8 @@
     if (priv->overflow_buf_len > 0) {
         int len = priv->overflow_buf_len;
 
+        qDebug() << "using overflow " << len << ":" << count;
+
         if (len > count)
             len = count;
 

=== modified file 'mixxx/plugins/soundsourcem4a/soundsourcem4a.cpp'
--- mixxx/plugins/soundsourcem4a/soundsourcem4a.cpp	2011-03-31 16:07:22 +0000
+++ mixxx/plugins/soundsourcem4a/soundsourcem4a.cpp	2012-08-25 14:32:20 +0000
@@ -131,7 +131,7 @@
 
     int total_bytes_to_decode = size * m_iChannels;
     int total_bytes_decoded = 0;
-    int num_bytes_req = 4096;
+    int num_bytes_req = 8192;
     char* buffer = (char*)destination;
     SAMPLE * as_buffer = (SAMPLE*) destination; //pointer for mono->stereo filling.
     do {

=== added file 'mixxx/res/controllers/Hercules DJ Control MP3 e2.cntrlr.xml'
--- mixxx/res/controllers/Hercules DJ Control MP3 e2.cntrlr.xml	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/Hercules DJ Control MP3 e2.cntrlr.xml	2012-08-25 14:32:20 +0000
@@ -0,0 +1,15 @@
+<?xml version='1.0' encoding='utf-8'?>
+<MixxxControllerPreset mixxxVersion="1.11+" schemaVersion="1">
+    <info>
+        <name>Hercules DJ Control MP3 e2</name>
+        <author>Neale Pickett</author>
+        <description>Hercules DJ Control MP3 e2</description>
+    </info>
+    <controller id="DJ">
+        <scriptfiles>
+            <file functionprefix="" filename="common-bulk-midi.js"/>
+            <file functionprefix="" filename="Hercules DJ Control MP3 e2-scripts.js"/>
+            <file functionprefix="MP3e2" filename="Hercules-mp3e2-compat.js"/>
+        </scriptfiles>
+    </controller>
+</MixxxControllerPreset>

=== added file 'mixxx/res/controllers/Hercules-mp3e2-compat.js'
--- mixxx/res/controllers/Hercules-mp3e2-compat.js	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/Hercules-mp3e2-compat.js	2012-08-25 14:32:20 +0000
@@ -0,0 +1,178 @@
+MP3e2 = Object()
+
+blink = new Object();
+
+function light(id, enable) {
+    if (enable == blink) {
+        bval = 0x7f;
+        val = 0;
+    } else {
+        bval = 0;
+        val = enable?0x7f:0;
+    }
+    midi.sendShortMsg(0x90, id, val);
+    midi.sendShortMsg(0x90, id + 0x30, bval);
+}
+
+function simpleButton(id) {
+    return function(val, group) {
+        var btn = (group == "[Channel1]")?(id):(id+20);
+
+        light(btn, !!val);
+    }
+}
+
+LEDs = [
+    ["loop_start_position", simpleButton(1)],
+    ["loop_end_position", simpleButton(2)],
+    ["loop_enabled", simpleButton(51)],
+    ["loop_enabled", simpleButton(52)],
+    ["hotcue_1_enabled", simpleButton(5)],
+    ["hotcue_2_enabled", simpleButton(6)],
+    ["hotcue_3_enabled", simpleButton(7)],
+    ["hotcue_4_enabled", simpleButton(8)],
+    ["flanger", simpleButton(67)],
+    ["play", simpleButton(15)],
+    ["pfl", simpleButton(16)],
+    ["beat_active", simpleButton(18)],
+];
+
+MP3e2.init = function(id) {
+    HerculesMP3e2.init(id);
+
+    // Set up LEDs
+    for (var i = 0; i < 2; i += 1) {
+        group = "[Channel" + (i+1) + "]";
+
+        for (var j in LEDs) {
+            var control = LEDs[j][0];
+            var func = LEDs[j][1];
+
+            engine.connectControl(group, control, func);
+            engine.trigger(group, control);
+        }
+    }
+}
+
+var c1 = '[Channel1]'
+var c2 = '[Channel2]'
+
+MP3e2.incomingData = function(data, length) {
+    for (var i = 0; i < length; i += 3) {
+        var status = data[i];
+        var midino = data[i+1];
+        var value = data[i+2];
+        var group;
+        var f = null;
+
+        if (status == 0xb0) {
+            if ((midino > 0x38) || 
+                ((midino < 0x34) && (midino & 1))) {
+                group = c2;
+            } else {
+                group = c1;
+            }
+        } else if (status == 0x90) {
+            if (midino <= 20) {
+                group = c1;
+            } else if (midino < 40) {
+                group = c2;
+            }
+        }
+
+        switch ((status<<8) | midino) {
+            case 0x9001: case 0x9015:
+            case 0x9002: case 0x9016:
+            case 0x9003: case 0x9017:
+            case 0x9004: case 0x9018:
+            case 0x9005: case 0x9019:
+            case 0x9006: case 0x901a:
+            case 0x9007: case 0x901b:
+            case 0x9008: case 0x901c:
+                f = HerculesMP3e2.keyButton;
+                break;
+            case 0x900a: case 0x901e:
+            case 0x900b: case 0x901f:
+                f = HerculesMP3e2.pitchbend;
+                break;
+            case 0x900c: case 0x9020:
+                f = "back";
+                break;
+            case 0x900d: case 0x9021:
+                f = "fwd";
+                break;
+            case 0x900e: case 0x9022:
+                f = HerculesMP3e2.cue;
+                break;
+            case 0x900f: case 0x9023:
+                if (value == 0) return;
+                f = "play";
+                value = ! engine.getValue(group, f);
+                break;
+            case 0x9010: case 0x9024:
+                if (value == 0) return;
+                f = "pfl";
+                value = ! engine.getValue(group, f);
+                break;
+            case 0x9011: case 0x9025:
+                f = HerculesMP3e2.loadTrack;
+                break;
+            case 0x9012: case 0x9026:
+                f = HerculesMP3e2.sync;
+                break;
+            case 0x9013: case 0x9027:
+                f = HerculesMP3e2.masterTempo;
+                break;
+
+
+            case 0x9029:
+                group = '[Playlist]';
+                f = 'SelectPrevTrack';
+                break;
+            case 0x902a:
+                group = '[Playlist]';
+                f = 'SelectNextTrack';
+                break;
+            case 0x902b:
+            case 0x902c:
+                group = '[Playlist]';
+                f = HerculesMP3e2.scroll;
+                break;
+            case 0x902d:
+                f = HerculesMP3e2.scratch;
+                break;
+            case 0x902e:
+                f = HerculesMP3e2.automix;
+                break;
+
+            case 0xb030: case 0xb031:
+                f = HerculesMP3e2.jogWheel;
+                break;
+            case 0xb032: case 0xb033:
+                f = HerculesMP3e2.pitch;
+                break;
+            case 0xb034: case 0xb039:
+                engine.setValue(group, "volume", script.absoluteLin(value, 0, 1));
+                break;
+            case 0xb035: case 0xb03a:
+                engine.setValue(group, "filterHigh", script.absoluteNonLin(value, 0, 1, 4));
+                break;
+            case 0xb036: case 0xb03b:
+                engine.setValue(group, "filterMid", script.absoluteNonLin(value, 0, 1, 4));
+                break;
+            case 0xb037: case 0xb03c:
+                engine.setValue(group, "filterLow", script.absoluteNonLin(value, 0, 1, 4));
+                break;
+            case 0xb038:
+                engine.setValue('[Master]', 'crossfader', script.absoluteLin(value, -1, 1));
+                break;
+        }
+
+        if (typeof(f) == 'string') {
+            engine.setValue(group, f, (value>0)?1:0);
+        } else if (f) {
+            f(0, midino, value, status, group);
+        }
+    }
+}
+

=== added file 'mixxx/res/controllers/Hercules-mp3e2.js'
--- mixxx/res/controllers/Hercules-mp3e2.js	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/Hercules-mp3e2.js	2012-08-25 14:32:20 +0000
@@ -0,0 +1,275 @@
+secondsBlink = 30;
+
+MP3e2 = new Object();
+
+function sendMsg(status, a, b) {
+    midi.sendShortMsg(status, a, b);
+    //controller.send([status, a, b], 3);
+}
+
+blink = new Object();
+
+function light(id, enable) {
+    if (enable == blink) {
+        bval = 0x7f;
+        val = 0;
+    } else {
+        bval = 0;
+        val = enable?0x7f:0;
+    }
+    sendMsg(0x90, id, val);
+    sendMsg(0x90, id + 0x30, bval);
+}
+
+function simpleButton(id) {
+    return function(val, group) {
+        var btn = (group == "[Channel1]")?(id):(id+20);
+
+        light(btn, !!val);
+    }
+}
+
+function toggleButton(id, val, group) {
+    var btn = (group == "[Channel1]")?(id):(id + 20);
+
+    light(btn, !!val);
+}
+
+function btn_loop_enabled(val, group) {
+    toggleButton(3, val, group);
+    toggleButton(4, val, group);
+}
+
+function btn_playposition(pos, group) {
+    var secondsToEnd = engine.getValue(group, "duration") * (1 - pos);
+    var btn = (group == "[Channel1]")?14:34;
+
+    if (secondsToEnd < 1) {
+        light(btn, false);
+    } else if (secondsToEnd < secondsBlink) {
+        light(btn, blink);
+    } else {
+        light(btn, true);
+    }
+}
+
+binds = [
+    ["loop_start_position", simpleButton(1)],
+    ["loop_end_position", simpleButton(2)],
+    ["hotcue_1_enabled", simpleButton(5)],
+    ["hotcue_2_enabled", simpleButton(6)],
+    ["hotcue_3_enabled", simpleButton(7)],
+    ["hotcue_4_enabled", simpleButton(8)],
+    ["play", simpleButton(15)],
+    ["pfl", simpleButton(16)],
+    ["playposition", btn_playposition],
+    ["loop_enabled", btn_loop_enabled],
+];
+
+meta = false;
+ctl_id = "";
+
+MP3e2.init = function(id) {
+    print("MP3e2 controller initialized: " + id);
+
+    ctl_id = id;
+
+    for (var i = 0; i < 2; i += 1) {
+        group = "[Channel" + (i+1) + "]";
+
+
+        for (var j in binds) {
+            var control = binds[j][0];
+            var func = binds[j][1];
+
+            engine.connectControl(group, control, func);
+            engine.trigger(group, control);
+        }
+    }
+
+    // Turn everything off
+    for (i = 1; i < 46; i += 1) {
+        light(i, false);
+    }
+
+    // Request all faders report position
+    sendMsg(0xb0, 0x7f, 0x7f);
+
+    // Turn on some lights
+    light(46, true);    // Automix
+    //light(14, true);    // Cue A
+    //light(34, true);    // Cue B
+}
+
+MP3e2.shutdown = function() {
+    controller.close();
+    print("MP3e2 controller shutdown: " + ctl_id);
+}
+
+meta_buttons = {
+     1: "loop_start_position",
+     2: "loop_end_position",
+     5: "hotcue_1_clear",
+     6: "hotcue_2_clear",
+     7: "hotcue_3_clear",
+     8: "hotcue_4_clear",
+};
+
+buttons = {
+     1: "loop_in",
+     2: "loop_out",
+     3: "reloop_exit",
+     4: "reloop_exit",
+     5: "hotcue_1_activate",
+     6: "hotcue_2_activate",
+     7: "hotcue_3_activate",
+     8: "hotcue_4_activate",
+    10: "rate_temp_down",
+    11: "rate_temp_up",
+    12: "back",
+    13: "fwd",
+    14: "cue_default",
+    15: "play",
+    16: "pfl",
+    17: "LoadSelectedTrack",
+    18: "beatsync",
+
+    41: "SelectPrevTrack",
+    42: "SelectNextTrack",
+};
+
+function handleButton(id, pressed) {
+    var val = pressed ? 1 : 0;
+    var did = id;
+    var group, ctl;
+
+    if (id > 40) {
+        group = '[Playlist]';
+    } else if (id > 20) {
+        group = '[Channel2]';
+        did -= 20;
+    } else {
+        group = '[Channel1]';
+    }
+
+    if (meta) {
+        ctl = meta_buttons[did];
+    }
+    if (! ctl) {
+        ctl = buttons[did];
+    }
+
+    print(id + ": " + ctl);
+    if (ctl) {
+        switch (did) {
+            case 1:
+            case 2:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                if (meta) {
+                    val = -pressed;
+                }
+                break;
+            case 15:
+            case 16:
+                // Ignore button release, toggle value
+                if (! pressed) {
+                    return;
+                }
+                val = ! engine.getValue(group, ctl);
+                break;
+        }
+
+        engine.setValue(group, ctl, val);
+        return;
+    }
+
+    switch (id) {
+        case 46:
+            meta = !!pressed;
+            light(30, meta);
+            light(31, meta);
+            light(10, meta);
+            light(11, meta);
+            light(19, meta);
+            light(39, meta);
+            break;
+    }
+}
+
+
+faders = {
+    0x35: "filterHigh",
+    0x36: "filterMid",
+    0x37: "filterLow"
+};
+
+function handleFader(id, val) {
+    if (id < 0x34) {
+        group = '[Channel' + ((id & 1) + 1) + ']';
+        id = id & 0xfe;
+    } else if (id < 0x39) {
+        group = '[Channel1]';
+    } else {
+        group = '[Channel2]';
+        id -= 5;
+    }
+
+    ctl = faders[id];
+
+    switch (id) {
+        case 0x30: // Jog wheel
+            if (val == 127) {
+                dir = -1;
+            } else {
+                dir = 1;
+            }
+            engine.setValue(group, "jog", dir);
+            break;
+        case 0x32: // Pitch adjust
+            if (val == 127) {
+                ctl = "rate_perm_down";
+            } else {
+                ctl = "rate_perm_up";
+            }
+            engine.setValue(group, ctl, 1);
+            engine.setValue(group, ctl, 0);
+            break;
+        case 0x34:
+            fval = script.absoluteLin(val, 0, 1);
+            engine.setValue(group, "volume", fval);
+            return;
+        case 0x35:
+        case 0x36:
+        case 0x37:
+            fval = script.absoluteNonLin(val, 0, 1, 4);
+            engine.setValue(group, ctl, fval);
+            break;
+        case 0x38: // Crossfader
+            fval = script.absoluteLin(val, -1, 1);
+            engine.setValue('[Master]', 'crossfader', fval);
+            break;
+    }
+}
+
+MP3e2.incomingData = function(data, length) {
+    for (i = 0; i < length; i += 3) {
+        switch (data[i]) {
+            case 0x90:
+                handleButton(data[i+1], data[i+2] == 0x7f);
+                break;
+            case 0xb0:
+                handleFader(data[i+1], data[i+2]);
+                break;
+            default:
+                print("Unhandled packet: " + 
+                      " 0x" + data[i].toString(16) +
+                      " 0x" + data[i+1].toString(16) +
+                      " 0x" + data[i+2].teString(16))
+                  break;
+        }
+    }
+}
+

=== added file 'mixxx/res/controllers/common-bulk-midi.js'
--- mixxx/res/controllers/common-bulk-midi.js	1970-01-01 00:00:00 +0000
+++ mixxx/res/controllers/common-bulk-midi.js	2012-08-25 14:32:20 +0000
@@ -0,0 +1,5 @@
+midi = new Object();
+
+midi.sendShortMsg = function(status, a, b) {
+    controller.send([status, a, b], 3);
+}

=== added directory 'mixxx/src/controllers/bulk'
=== added file 'mixxx/src/controllers/bulk/bulkcontroller.cpp'
--- mixxx/src/controllers/bulk/bulkcontroller.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/controllers/bulk/bulkcontroller.cpp	2012-08-25 14:32:20 +0000
@@ -0,0 +1,274 @@
+/**
+  * @file bulkcontroller.cpp
+  * @author Neale Pickett  [e-mail]
+  * @date Thu Jun 28 2012
+  * @brief USB Bulk controller backend
+  *
+  */
+
+#include "controllers/bulk/bulkcontroller.h"
+#include "controllers/bulk/bulksupported.h"
+
+#include <time.h>
+#include <stdio.h>
+
+
+/* This is for my debugging, because I like typing
+       DUMP();
+   more than typing
+       qDebug() << "foo";
+ */
+#ifdef NODUMP
+#  define DUMPf(fmt, args...)
+#else
+#  define DUMPf(fmt, args...) fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, ##args)
+#endif
+#define DUMP() DUMPf("")
+#define DUMP_d(v) DUMPf("%s = %d", #v, v)
+#define DUMP_x(v) DUMPf("%s = 0x%x", #v, v)
+#define DUMP_s(v) DUMPf("%s = %s", #v, v)
+#define DUMP_c(v) DUMPf("%s = '%c' (0x%02x)", #v, v, v)
+#define DUMP_p(v) DUMPf("%s = %p", #v, v)
+
+BulkReader::BulkReader(libusb_device_handle *handle, unsigned char in_epaddr)
+        : QThread() {
+    m_phandle = handle;
+    m_in_epaddr = in_epaddr;
+}
+
+BulkReader::~BulkReader() {
+    m_phandle = NULL;
+}
+
+void BulkReader::stop() {
+    m_stop = 1;
+}
+
+void BulkReader::run() {
+    m_stop = 0;
+    unsigned char data[255];
+
+    while (m_stop == 0) {
+        // Blocked polling: The only problem with this is that we can't close
+        // the device until the block is released, which means the controller
+        // has to send more data
+        //result = hid_read_timeout(m_pHidDevice, data, 255, -1);
+
+        // This relieves that at the cost of higher CPU usage since we only
+        // block for a short while (500ms)
+        int transferred;
+        int result;
+
+        result = libusb_bulk_transfer(m_phandle,
+                                      m_in_epaddr,
+                                      data, sizeof data,
+                                      &transferred, 500);
+        if (result >= 0) {
+            //qDebug() << "Read" << result << "bytes, pointer:" << data;
+            QByteArray outData((char *)data, transferred);
+            emit(incomingData(outData));
+        }
+
+    }
+    qDebug() << "Stopped Reader";
+}
+
+static QString
+get_string(libusb_device_handle *handle, u_int8_t id)
+{
+    unsigned char buf[128];
+    QString s;
+
+    buf[0] = 0;
+    if (id) {
+        (void)libusb_get_string_descriptor_ascii(handle, id, buf, sizeof buf);
+    } 
+
+    return QString::fromAscii((char *)buf);
+}
+
+
+BulkController::BulkController(libusb_device_handle *handle,
+                               struct libusb_device_descriptor *desc)
+{
+    vendor_id = desc->idVendor;
+    product_id = desc->idProduct;
+
+    manufacturer = get_string(handle, desc->iManufacturer);
+    product = get_string(handle, desc->iProduct);
+    m_sUID = get_string(handle, desc->iSerialNumber);
+
+    setDeviceCategory(tr("USB Controller"));
+
+    setDeviceName(QString("%1 %2").arg(product).arg(m_sUID));
+
+    setInputDevice(true);
+    setOutputDevice(true);
+    m_pReader = NULL;
+}
+
+BulkController::~BulkController() {
+    close();
+}
+
+void BulkController::visit(const MidiControllerPreset* preset) {
+    Q_UNUSED(preset);
+    // TODO(XXX): throw a hissy fit.
+    qDebug() << "ERROR: Attempting to load a MidiControllerPreset to an HidController!";
+}
+
+void BulkController::visit(const HidControllerPreset* preset) {
+    m_preset = *preset;
+    // Emit presetLoaded with a clone of the preset.
+    emit(presetLoaded(getPreset()));
+}
+
+bool BulkController::savePreset(const QString fileName) const {
+    HidControllerPresetFileHandler handler;
+    return handler.save(m_preset, getName(), fileName);
+}
+
+bool BulkController::matchPreset(const PresetInfo& preset) {
+    const QList< QHash<QString,QString> > products = preset.getProducts();
+    QHash <QString, QString> product;
+    foreach (product, products) {
+        if (matchProductInfo(product))
+            return true;
+    }
+    return false;
+}
+
+bool BulkController::matchProductInfo(QHash <QString,QString > info) {
+    int value;
+    bool ok;
+    // Product and vendor match is always required
+    value = info["vendor_id"].toInt(&ok,16);
+    if (!ok || vendor_id!=value) return false;
+    value = info["product_id"].toInt(&ok,16);
+    if (!ok || product_id!=value) return false;
+
+    // Match found
+    return true;
+}
+
+int BulkController::open() {
+    int i;
+
+    if (isOpen()) {
+        qDebug() << "USB Bulk device" << getName() << "already open";
+        return -1;
+    }
+
+    /* Look up endpoint addresses in supported database */
+    for (i = 0; bulk_supported[i].vendor_id; i += 1) {
+        if ((bulk_supported[i].vendor_id == vendor_id) && 
+            (bulk_supported[i].product_id == product_id)) {
+            in_epaddr = bulk_supported[i].in_epaddr;
+            out_epaddr = bulk_supported[i].out_epaddr;
+            break;
+        }
+    }
+
+    if (bulk_supported[i].vendor_id == 0) {
+        qWarning() << "USB Bulk device" << getName() << "unsupported";
+        return -1;
+    }
+    m_phandle = NULL;
+
+    // XXX: we should enumerate devices and match vendor, product, and serial
+    if (m_phandle == NULL) {
+        m_phandle = libusb_open_device_with_vid_pid(NULL, vendor_id, product_id);
+    }
+
+    if (m_phandle == NULL) {
+        qWarning()  << "Unable to open USB Bulk device" << getName();
+        return -1;
+    }
+
+    setOpen(true);
+    startEngine();
+
+    if (m_pReader != NULL) {
+        qWarning() << "BulkReader already present for" << getName();
+    } else {
+        m_pReader = new BulkReader(m_phandle, in_epaddr);
+        m_pReader->setObjectName(QString("BulkReader %1").arg(getName()));
+
+        connect(m_pReader, SIGNAL(incomingData(QByteArray)),
+                this, SLOT(receive(QByteArray)));
+
+        // Controller input needs to be prioritized since it can affect the
+        // audio directly, like when scratching
+        m_pReader->start(QThread::HighPriority);
+    }
+
+    return 0;
+}
+
+int BulkController::close() {
+    if (!isOpen()) {
+        qDebug() << " device" << getName() << "already closed";
+        return -1;
+    }
+
+    qDebug() << "Shutting down USB Bulk device" << getName();
+
+    // Stop the reading thread
+    if (m_pReader == NULL) {
+        qWarning() << "BulkReader not present for" << getName()
+                   << "yet the device is open!";
+    } else {
+        disconnect(m_pReader, SIGNAL(incomingData(QByteArray)),
+                   this, SLOT(receive(QByteArray)));
+        m_pReader->stop();
+        if (debugging()) qDebug() << "  Waiting on reader to finish";
+        m_pReader->wait();
+        delete m_pReader;
+        m_pReader = NULL;
+    }
+
+    // Stop controller engine here to ensure it's done before the device is closed
+    //  incase it has any final parting messages
+    stopEngine();
+
+    // Close device
+    if (debugging()) {
+        qDebug() << "  Closing device";
+    }
+    libusb_close(m_phandle);
+    setOpen(false);
+    return 0;
+}
+
+void BulkController::send(QList<int> data, unsigned int length) {
+    Q_UNUSED(length);
+    QByteArray temp;
+
+    foreach (int datum, data) {
+        temp.append(datum);
+    }
+    send(temp);
+}
+
+void BulkController::send(QByteArray data) {
+    int ret;
+    int transferred;
+
+    // XXX: don't get drunk again.
+    ret = libusb_bulk_transfer(m_phandle, out_epaddr,
+                               (unsigned char *)data.constData(), data.size(),
+                               &transferred, 0);
+    if (ret < 0) {
+        if (debugging()) {
+            qWarning() << "Unable to send data to" << getName()
+                       << "serial #" << m_sUID << ":"
+                       << QString::fromAscii(libusb_error_name(ret));
+        } else {
+            qWarning() << "Unable to send data to" << getName() << ":"
+                       << QString::fromAscii(libusb_error_name(ret));
+        }
+    } else if (debugging()) {
+        qDebug() << ret << "bytes sent to" << getName()
+                 << "serial #" << m_sUID;
+    }
+}

=== added file 'mixxx/src/controllers/bulk/bulkcontroller.h'
--- mixxx/src/controllers/bulk/bulkcontroller.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/controllers/bulk/bulkcontroller.h	2012-08-25 14:32:20 +0000
@@ -0,0 +1,105 @@
+/**
+  * @file bulkcontroller.h
+  * @author Neale Picket  [e-mail]
+  * @date Thu Jun 28 2012
+  * @brief USB Bulk controller backend
+  */
+
+#ifndef BULKCONTROLLER_H
+#define BULKCONTROLLER_H
+
+#include <libusb.h>
+
+#include <QAtomicInt>
+
+#include "controllers/controller.h"
+#include "controllers/hid/hidcontrollerpreset.h"
+#include "controllers/hid/hidcontrollerpresetfilehandler.h"
+
+class BulkReader : public QThread {
+    Q_OBJECT
+  public:
+    BulkReader(libusb_device_handle *handle, unsigned char in_epaddr);
+    virtual ~BulkReader();
+
+    void stop();
+
+  signals:
+    void incomingData(QByteArray data);
+
+  protected:
+    void run();
+
+  private:
+    libusb_device_handle *m_phandle;
+    QAtomicInt m_stop;
+    unsigned char m_in_epaddr;
+};
+
+class BulkController : public Controller {
+    Q_OBJECT
+  public:
+    BulkController(libusb_device_handle *handle, struct libusb_device_descriptor *desc);
+    virtual ~BulkController();
+
+    virtual ControllerPresetPointer getPreset() const {
+        HidControllerPreset* pClone = new HidControllerPreset();
+        *pClone = m_preset;
+        return ControllerPresetPointer(pClone);
+    }
+
+    virtual bool savePreset(const QString fileName) const;
+
+    virtual ControllerPresetFileHandler* getFileHandler() const {
+        return new HidControllerPresetFileHandler();
+    }
+
+    virtual void visit(const MidiControllerPreset* preset);
+    virtual void visit(const HidControllerPreset* preset);
+
+    virtual bool isMappable() const {
+        return m_preset.isMappable();
+    }
+
+    virtual bool matchPreset(const PresetInfo& preset);
+    virtual bool matchProductInfo(QHash <QString,QString >);
+
+  protected:
+    Q_INVOKABLE void send(QList<int> data, unsigned int length);
+
+  private slots:
+    int open();
+    int close();
+
+  private:
+    // For devices which only support a single report, reportID must be set to
+    // 0x0.
+    virtual void send(QByteArray data);
+
+    virtual bool isPolling() const {
+        return false;
+    }
+
+    // Returns a pointer to the currently loaded controller preset. For internal
+    // use only.
+    virtual ControllerPreset* preset() {
+        return &m_preset;
+    }
+
+    libusb_device_handle *m_phandle;
+
+    // Local copies of things we need from desc
+
+    unsigned short vendor_id;
+    unsigned short product_id;
+    unsigned char in_epaddr;
+    unsigned char out_epaddr;
+    QString manufacturer;
+    QString product;
+
+    QString m_sUID;
+    BulkReader* m_pReader;
+    HidControllerPreset m_preset;
+};
+
+#endif

=== added file 'mixxx/src/controllers/bulk/bulkenumerator.cpp'
--- mixxx/src/controllers/bulk/bulkenumerator.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/controllers/bulk/bulkenumerator.cpp	2012-08-25 14:32:20 +0000
@@ -0,0 +1,71 @@
+/**
+ * @file bulkenumerator.cpp
+ * @author Neale Picket  [e-mail]
+ * @date Thu Jun 28 2012
+ * @brief USB Bulk controller backend
+ */
+
+#include <libusb.h>
+
+#include "controllers/bulk/bulkcontroller.h"
+#include "controllers/bulk/bulkenumerator.h"
+#include "controllers/bulk/bulksupported.h"
+
+BulkEnumerator::BulkEnumerator() : ControllerEnumerator() {
+    libusb_init(NULL);
+}
+
+BulkEnumerator::~BulkEnumerator() {
+    qDebug() << "Deleting USB Bulk devices...";
+    while (m_devices.size() > 0) {
+        delete m_devices.takeLast();
+    }
+    libusb_exit(NULL);
+}
+
+static int
+is_interesting(struct libusb_device_descriptor *desc)
+{
+    int i;
+
+    for (i = 0; bulk_supported[i].vendor_id; i += 1) {
+        if ((bulk_supported[i].vendor_id == desc->idVendor) && 
+            (bulk_supported[i].product_id == desc->idProduct)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+QList<Controller*> BulkEnumerator::queryDevices() {
+    qDebug() << "Scanning USB Bulk devices:";
+
+    libusb_device **list;
+    ssize_t cnt = libusb_get_device_list(NULL, &list);
+    ssize_t i = 0;
+    int err = 0;
+
+    for (i = 0; i < cnt; i++) {
+        libusb_device *device = list[i];
+        struct libusb_device_descriptor desc;
+
+        libusb_get_device_descriptor(device, &desc);
+        if (is_interesting(&desc)) {
+            struct libusb_device_handle *handle;
+
+            err = libusb_open(device, &handle);
+            if (err) {
+                qDebug() << "Error opening a device";
+                continue;
+            }
+
+            BulkController* currentDevice = new BulkController(handle, &desc);
+            m_devices.push_back(currentDevice);
+        }
+    }
+
+    libusb_free_device_list(list, 1);
+
+    return m_devices;
+}

=== added file 'mixxx/src/controllers/bulk/bulkenumerator.h'
--- mixxx/src/controllers/bulk/bulkenumerator.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/controllers/bulk/bulkenumerator.h	2012-08-25 14:32:20 +0000
@@ -0,0 +1,24 @@
+/**
+* @file bulkenumerator.h
+* @author Neale Pickett  [e-mail]
+* @date Thu Jun 28 2012
+* @brief Locate supported USB bulk controllers
+*/
+
+#ifndef BULKENUMERATOR_H
+#define BULKENUMERATOR_H
+
+#include "controllers/controllerenumerator.h"
+
+class BulkEnumerator : public ControllerEnumerator {
+  public:
+    BulkEnumerator();
+    virtual ~BulkEnumerator();
+
+    QList<Controller*> queryDevices();
+
+  private:
+    QList<Controller*> m_devices;
+};
+
+#endif

=== added file 'mixxx/src/controllers/bulk/bulksupported.h'
--- mixxx/src/controllers/bulk/bulksupported.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/controllers/bulk/bulksupported.h	2012-08-25 14:32:20 +0000
@@ -0,0 +1,24 @@
+/**
+* @file bulksupported.h
+* @author Neale Picket  [e-mail]
+* @date Thu Jun 28 2012
+* @brief A list of supported USB bulk devices
+*/
+
+#ifndef BULKSUPPORTED_H
+#define BULKSUPPORTED_H
+
+typedef struct bulk_supported {
+    unsigned short vendor_id;
+    unsigned short product_id;
+    unsigned char in_epaddr;
+    unsigned char out_epaddr;
+} bulk_supported_t;
+
+static bulk_supported_t bulk_supported[] = {
+    {0x06f8, 0xb105, 0x82, 0x03},   // Hercules MP3e2
+    {0x06f8, 0xb100, 0x86, 0x06},   // Hercules Mk2
+    {0, 0, 0, 0}
+};
+
+#endif

=== modified file 'mixxx/src/controllers/controllermanager.cpp'
--- mixxx/src/controllers/controllermanager.cpp	2012-07-08 23:27:47 +0000
+++ mixxx/src/controllers/controllermanager.cpp	2012-08-25 14:32:20 +0000
@@ -21,6 +21,10 @@
     #include "controllers/hid/hidenumerator.h"
 #endif
 
+#ifdef __BULK__
+#    include "controllers/bulk/bulkenumerator.h"
+#endif
+
 // http://developer.qt.nokia.com/wiki/Threads_Events_QObjects
 
 // Poll every 1ms (where possible) for good controller response
@@ -77,6 +81,9 @@
 #ifdef __HSS1394__
     m_enumerators.append(new Hss1394Enumerator());
 #endif
+#ifdef __BULK__
+    m_enumerators.append(new BulkEnumerator());
+#endif
 #ifdef __HID__
     m_enumerators.append(new HidEnumerator());
 #endif