Basic project based on DrumGizmo.

40 files changed, 3685 insertions, 0 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..038bcce
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,44 @@
+include $(top_srcdir)/plugingui/Makefile.am.plugingui
+
+plugindir = $(libdir)/lv2/camsync.lv2
+
+plugin_LTLIBRARIES = camsync.la
+
+plugin_DATA = manifest.ttl camsync.ttl
+
+EXTRA_DIST = \
+	$(plugin_DATA) \
+	input_lv2.h \
+	output_lv2.h \
+	lv2_event.h \
+	lv2_gui.h \
+	lv2_instance.h
+
+camsync_la_CXXFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/plugingui \
+	-I$(top_srcdir)/include $(SNDFILE_CXXFLAGS) \
+	$(PTHREAD_CFLAGS) $(EXPAT_CFLAGS) $(LV2_CFLAGS) \
+	$(PLUGIN_GUI_CFLAGS) $(SSEFLAGS) $(ZITA_CPPFLAGS) \
+	-DUSE_THREAD $(SAMPLERATE_CFLAGS)
+
+camsync_la_SOURCES = \
+	configfile.cc \
+	configuration.cc \
+	configparser.cc \
+	events.cc \
+	messagehandler.cc \
+	messagereceiver.cc \
+	mutex.cc \
+	path.cc \
+	semaphore.cc \
+	saxparser.cc \
+	thread.cc \
+	versionstr.cc
+	$(PLUGIN_GUI_SOURCES) \
+	lv2.cc \
+	lv2_gui.cc \
+	input_lv2.cc \
+	output_lv2.cc
+
+camsync_la_LDFLAGS = -module -avoid-version
+camsync_la_LIBADD = $(LV2_LIBS) $(PLUGIN_GUI_LIBS) \
+	$(ZITA_LIBS) $(SNDFILE_LIBS) $(EXPAT_LIBS) $(SAMPLERATE_LIBS)
diff --git a/src/camsync.ttl b/src/camsync.ttl
new file mode 100644
index 0000000..23345f3
--- /dev/null
+++ b/src/camsync.ttl
@@ -0,0 +1,144 @@
+# LV2 DrumGizmo Plugin
+# Copyright 2011 Bent Bisballe Nyeng <deva@aasimon.org>
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+@prefix doap:  <http://usefulinc.com/ns/doap#> .
+@prefix foaf:  <http://xmlns.com/foaf/0.1/> .
+@prefix lv2:   <http://lv2plug.in/ns/lv2core#> .
+@prefix atom:  <http://lv2plug.in/ns/ext/atom#> .
+@prefix uiext: <http://lv2plug.in/ns/extensions/ui#> .
+@prefix state: <http://lv2plug.in/ns/ext/state#> .
+
+<http://drumgizmo.org/lv2-gui>
+    a uiext:external ;
+    uiext:binary <drumgizmo.so> .
+
+<http://drumgizmo.org/lv2>
+	a lv2:InstrumentPlugin ;
+	doap:name "DrumGizmo" ;
+	doap:maintainer [
+		foaf:name "DrumGizmo.org";
+		foaf:homepage <http://www.drumgizmo.org> ;
+	] ;
+	doap:license <http://usefulinc.com/doap/licenses/gpl> ;
+	uiext:ui <http://drumgizmo.org/lv2-gui> ;
+	doap:license <http://opensource.org/licenses/gpl-3.0> ;
+	lv2:optionalFeature <http://lv2plug.in/ns/ext/uri-map> ;
+	lv2:optionalFeature <http://lv2plug.in/ns/ext/event> ;
+  lv2:extensionData state:interface ;
+lv2:port [
+		a atom:AtomPort ,
+      lv2:InputPort; 
+    atom:bufferType atom:Sequence ;
+    atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ;
+    lv2:index 0 ;
+		lv2:symbol "control" ;
+		lv2:name "Control"
+	] , [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 1 ;
+		lv2:symbol "out1" ;
+		lv2:name "Out1"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 2 ;
+		lv2:symbol "out2" ;
+		lv2:name "Out2"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 3 ;
+		lv2:symbol "out3" ;
+		lv2:name "Out3"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 4 ;
+		lv2:symbol "out4" ;
+		lv2:name "Out4"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 5 ;
+		lv2:symbol "out5" ;
+		lv2:name "Out5"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 6 ;
+		lv2:symbol "out6" ;
+		lv2:name "Out6"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 7 ;
+		lv2:symbol "out7" ;
+		lv2:name "Out7"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 8 ;
+		lv2:symbol "out8" ;
+		lv2:name "Out8"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 9 ;
+		lv2:symbol "out9" ;
+		lv2:name "Out9"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 10 ;
+		lv2:symbol "out10" ;
+		lv2:name "Out10"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 11 ;
+		lv2:symbol "out11" ;
+		lv2:name "Out11"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 12 ;
+		lv2:symbol "out12" ;
+		lv2:name "Out12"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 13 ;
+		lv2:symbol "out13" ;
+		lv2:name "Out13"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 14 ;
+		lv2:symbol "out14" ;
+		lv2:name "Out14"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 15 ;
+		lv2:symbol "out15" ;
+		lv2:name "Out15"
+	], [
+		a lv2:AudioPort ,
+			lv2:OutputPort ;
+		lv2:index 16 ;
+		lv2:symbol "out16" ;
+		lv2:name "Out16"
+	] .
diff --git a/src/configfile.cc b/src/configfile.cc
new file mode 100644
index 0000000..6b0d14f
--- /dev/null
+++ b/src/configfile.cc
@@ -0,0 +1,347 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configfile.cc
+ *
+ *  Thu May 14 14:51:39 CEST 2015
+ *  Copyright 2015 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "configfile.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef WIN32
+#include <direct.h>
+#include <windows.h>
+#include <Shlobj.h>
+#include <Shlwapi.h>
+#else
+#endif
+
+#include <hugin.hpp>
+  
+#ifdef WIN32
+  #define SEP "\\"
+#else
+  #define SEP "/"
+#endif
+
+#define CONFIGDIRNAME ".drumgizmo"
+
+/**
+ * Return the path containing the config files.
+ */
+static std::string configPath()
+{
+#ifdef WIN32
+  std::string configpath;
+  TCHAR szPath[256];
+  if(SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE,
+                               NULL, 0, szPath))) {
+    configpath = szPath;
+  }
+#else
+  std::string configpath = strdup(getenv("HOME"));
+#endif
+  configpath += SEP;
+  configpath += CONFIGDIRNAME;
+
+  return configpath;
+}
+
+/**
+ * Calling this makes sure that the config path exists
+ */
+static bool createConfigPath()
+{
+  std::string configpath = configPath();
+
+  struct stat st;
+  if(stat(configpath.c_str(), &st) == 0) {
+    DEBUG(configfile, "No configuration exists, creating directory '%s'\n",
+          configpath.c_str());
+#ifdef WIN32
+    if(mkdir(configpath.c_str()) < 0) { 
+#else
+    if(mkdir(configpath.c_str(), 0755) < 0) { 
+#endif
+      DEBUG(configfile, "Could not create config directory\n");
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+ConfigFile::ConfigFile(std::string filename)
+  : filename(filename)
+  , fp(NULL)
+{
+}
+
+ConfigFile::~ConfigFile()
+{
+}
+
+bool ConfigFile::load()
+{
+  DEBUG(configfile, "Loading config file...\n");
+  if(!open("r")) {
+    return false;
+  }
+
+  values.clear();
+
+  std::string line;
+  while(true) {
+    line = readLine();
+
+    if(line == "") break;
+    
+    if(!parseLine(line)) {
+      return false;
+    }
+  }
+
+  close();
+
+  return true;
+}
+
+bool ConfigFile::save()
+{
+  DEBUG(configfile, "Saving configuration...\n");
+
+  createConfigPath();
+
+  if(!open("w")) {
+    return false;
+  }
+
+  std::map<std::string, std::string>::iterator v = values.begin();
+  for(; v != values.end(); ++v) {
+    fprintf(fp, "%s:%s\n", v->first.c_str(), v->second.c_str());
+  }
+
+  close();
+
+  return true;
+}
+
+std::string ConfigFile::getValue(const std::string& key)
+{
+  if(values.find(key) != values.end()) {
+    return values[key];
+  }
+
+  return "";
+}
+
+void ConfigFile::setValue(const std::string& key, const std::string& value)
+{
+  values[key] = value;
+}
+
+bool ConfigFile::open(std::string mode)
+{
+  if(fp) close();
+
+  std::string configpath = configPath();
+
+  std::string configfile = configpath;
+  configfile += SEP;
+  configfile += filename;
+
+  DEBUG(configfile, "Opening config file '%s'\n", configfile.c_str());
+  fp = fopen(configfile.c_str(), mode.c_str());
+
+  if(!fp) return false;
+
+  return true;
+}
+
+void ConfigFile::close()
+{
+  fclose(fp);
+  fp = NULL;
+}
+
+std::string ConfigFile::readLine()
+{
+  if(!fp) return "";
+
+  std::string line;
+
+  char buf[1024];
+  while(!feof(fp)) {
+    char *s = fgets(buf, sizeof(buf), fp);
+    if(s) {
+      line += buf;
+      if(buf[strlen(buf) - 1] == '\n') break;
+    }
+  }
+
+  return line;
+}
+
+bool ConfigFile::parseLine(const std::string& line)
+{
+  std::string key;
+  std::string value;
+  enum {
+    before_key,
+    in_key,
+    after_key,
+    before_value,
+    in_value,
+    in_value_single_quoted,
+    in_value_double_quoted,
+    after_value,
+  } state = before_key;
+
+  for(std::size_t p = 0; p < line.size(); ++p) {
+    switch(state) {
+    case before_key:
+      if(line[p] == '#') {
+        // Comment: Ignore line.
+        p = line.size();
+        continue;
+      }
+      if(std::isspace(line[p])) {
+        continue;
+      }
+      key += line[p];
+      state = in_key;
+      break;
+
+    case in_key:
+      if(std::isspace(line[p])) {
+        state = after_key;
+        continue;
+      }
+      if(line[p] == ':' || line[p] == '=') {
+        state = before_value;
+        continue;
+      }
+      key += line[p];
+      break;
+
+    case after_key:
+      if(std::isspace(line[p])) {
+        continue;
+      }
+      if(line[p] == ':' || line[p] == '=') {
+        state = before_value;
+        continue;
+      }
+      ERR(configfile, "Bad symbol."
+            " Expecting only whitespace or key/value seperator: '%s'",
+            line.c_str());
+      return false;
+
+    case before_value:
+      if(std::isspace(line[p])) {
+        continue;
+      }
+      if(line[p] == '\'') {
+        state = in_value_single_quoted;
+        continue;
+      }
+      if(line[p] == '"') {
+        state = in_value_double_quoted;
+        continue;
+      }
+      value += line[p];
+      state = in_value;
+      break;
+
+    case in_value:
+      if(std::isspace(line[p])) {
+        state = after_value;
+        continue;
+      }
+      if(line[p] == '#') {
+        // Comment: Ignore the rest of the line.
+        p = line.size();
+        state = after_value;
+        continue;
+      }
+      value += line[p];
+      break;
+
+    case in_value_single_quoted:
+      if(line[p] == '\'') {
+        state = after_value;
+        continue;
+      }
+      value += line[p];
+      break;
+
+    case in_value_double_quoted:
+      if(line[p] == '"') {
+        state = after_value;
+        continue;
+      }
+      value += line[p];
+      break;
+
+    case after_value:
+      if(std::isspace(line[p])) {
+        continue;
+      }
+      if(line[p] == '#') {
+        // Comment: Ignore the rest of the line.
+        p = line.size();
+        continue;
+      }
+      ERR(configfile, "Bad symbol."
+            " Expecting only whitespace or key/value seperator: '%s'",
+            line.c_str());
+      return false;
+    }
+  }
+
+  if(state == before_key) {
+    // Line did not contain any data (empty or comment)
+    return true;
+  }
+
+  // If state == in_value_XXX_quoted here, the string was not terminated.
+  if(state != after_value && state != in_value) {
+    ERR(configfile,"Malformed line: '%s'", line.c_str());
+    return false;
+  }
+
+  DEBUG(configfile, "key['%s'] value['%s']\n", key.c_str(), value.c_str());
+
+  if(key != "") {
+    values[key] = value;
+  }
+
+  return true;
+}
diff --git a/src/configfile.h b/src/configfile.h
new file mode 100644
index 0000000..a6c50bd
--- /dev/null
+++ b/src/configfile.h
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configfile.h
+ *
+ *  Thu May 14 14:51:38 CEST 2015
+ *  Copyright 2015 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_CONFIGFILE_H__
+#define __DRUMGIZMO_CONFIGFILE_H__
+
+#include <string>
+#include <map>
+#include <stdio.h>
+
+class ConfigFile {
+public:
+  ConfigFile(std::string filename);
+  virtual ~ConfigFile();
+
+  virtual bool load();
+  virtual bool save();
+
+  virtual std::string getValue(const std::string& key);
+  virtual void setValue(const std::string& key, const std::string& value);
+
+protected:
+  std::map<std::string, std::string> values;
+  std::string filename;
+
+  virtual bool open(std::string mode);
+  void close();
+  std::string readLine();
+  bool parseLine(const std::string& line);
+
+  FILE* fp;
+};
+
+#endif/*__DRUMGIZMO_CONFIGFILE_H__*/
diff --git a/src/configparser.cc b/src/configparser.cc
new file mode 100644
index 0000000..96e701b
--- /dev/null
+++ b/src/configparser.cc
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configparser.cc
+ *
+ *  Sat Jun 29 21:55:02 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "configparser.h"
+
+#include <hugin.hpp>
+
+#include "saxparser.h"
+
+ConfigParser::ConfigParser()
+{
+  str = NULL;
+}
+
+void ConfigParser::characterData(std::string &data)
+{
+  if(str) str->append(data);
+}
+
+void ConfigParser::startTag(std::string name, attr_t attr)
+{
+  if(name == "value" && attr.find("name") != attr.end()) {
+    values[attr["name"]] = "";
+    str = &values[attr["name"]];
+  }
+}
+
+void ConfigParser::endTag(std::string name)
+{
+  if(name == "value") str = NULL;
+}
+
+std::string ConfigParser::value(std::string name, std::string def)
+{
+  if(values.find(name) == values.end()) return def;
+  return values[name];
+}
+
+void ConfigParser::parseError(char *buf, size_t len, std::string error,
+                              int lineno)
+{
+  std::string buffer;
+  buffer.append(buf, len);
+  ERR(configparser, "sax parser error '%s' at line %d. "
+      "Buffer: [%d bytes]<%s>\n",
+      error.c_str(), lineno, (int)len, buffer.c_str());
+}
diff --git a/src/configparser.h b/src/configparser.h
new file mode 100644
index 0000000..e67babd
--- /dev/null
+++ b/src/configparser.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configparser.h
+ *
+ *  Sat Jun 29 21:55:02 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_CONFIGPARSER_H__
+#define __DRUMGIZMO_CONFIGPARSER_H__
+
+#include <map>
+
+#include "saxparser.h"
+
+class ConfigParser : public SAXParser {
+public:
+  ConfigParser();
+
+  void characterData(std::string &data);
+  void startTag(std::string name, attr_t attr);
+  void endTag(std::string name);
+  std::string value(std::string name, std::string def = "");
+  void parseError(char *buf, size_t len, std::string error, int lineno);
+
+private:
+  std::map<std::string, std::string> values;
+  std::string *str;
+};
+
+#endif/*__DRUMGIZMO_CONFIGPARSER_H__*/
diff --git a/src/configuration.cc b/src/configuration.cc
new file mode 100644
index 0000000..5c733ee
--- /dev/null
+++ b/src/configuration.cc
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configuration.cc
+ *
+ *  Sat Oct  8 14:37:14 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "configuration.h"
+
+bool Conf::enable_velocity_modifier = true;
+float Conf::velocity_modifier_falloff = 0.5;
+float Conf::velocity_modifier_weight = 0.25;
+
+bool Conf::enable_velocity_randomiser = false;
+float Conf::velocity_randomiser_weight = 0.1;
+
+int Conf::samplerate = 44100;
+
+bool Conf::enable_resampling = true;
diff --git a/src/configuration.h b/src/configuration.h
new file mode 100644
index 0000000..b8be49f
--- /dev/null
+++ b/src/configuration.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            configuration.h
+ *
+ *  Sat Oct  8 14:37:13 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_CONFIGURATION_H__
+#define __DRUMGIZMO_CONFIGURATION_H__
+
+namespace Conf {
+  extern bool enable_velocity_modifier;
+  extern float velocity_modifier_falloff;
+  extern float velocity_modifier_weight;
+
+  extern bool enable_velocity_randomiser;
+  extern float velocity_randomiser_weight;
+
+  extern int samplerate;
+
+  extern bool enable_resampling;
+};
+
+
+#endif/*__DRUMGIZMO_CONFIGURATION_H__*/
diff --git a/src/input_lv2.cc b/src/input_lv2.cc
new file mode 100644
index 0000000..e70d293
--- /dev/null
+++ b/src/input_lv2.cc
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            input_lv2.cc
+ *
+ *  Wed Jul 13 14:27:02 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "input_lv2.h"
+
+#include "lv2/lv2plug.in/ns/ext/atom/util.h"
+
+#include <midimapparser.h>
+
+#include <hugin.hpp>
+
+InputLV2::InputLV2()
+{
+  eventPort = NULL;
+}
+
+InputLV2::~InputLV2()
+{
+}
+
+bool InputLV2::init(Instruments &i)
+{
+  instruments = &i;
+  return true;
+}
+
+void InputLV2::setParm(std::string parm, std::string value)
+{
+}
+
+bool InputLV2::start()
+{
+  return true;
+}
+
+void InputLV2::stop()
+{
+}
+
+void InputLV2::pre()
+{
+}
+
+event_t *InputLV2::run(size_t pos, size_t len, size_t *nevents)
+{
+  if(eventPort == NULL) {
+    *nevents = 0;
+    return NULL;
+  }
+
+  event_t *list;
+  size_t listsize;
+
+  list = (event_t *)malloc(sizeof(event_t) * 1000);
+  listsize = 0;
+
+  LV2_Atom_Event* ev = lv2_atom_sequence_begin(&eventPort->body);
+
+  while(!lv2_atom_sequence_is_end(&eventPort->body,
+                                  eventPort->atom.size, 
+                                  ev)) {
+    uint8_t* const data = (uint8_t*)(ev+1);
+
+    if ((data[0] & 0xF0) == 0x80) { // note off
+      int key = data[1];
+    
+      DEBUG(lv2input, "Event (off) key:%d\n", key);
+    }
+
+    if ((data[0] & 0xF0) == 0x90) { // note on
+      int key = data[1];
+      int velocity = data[2];
+    
+      DEBUG(lv2input, "Event key:%d vel:%d\n", key, velocity);
+    
+      int i = mmap.lookup(key);
+      if(velocity && i != -1) {
+        list[listsize].type = TYPE_ONSET;
+        list[listsize].instrument = i;
+        list[listsize].velocity = velocity / 127.0;
+        list[listsize].offset = ev->time.frames;
+        listsize++;
+      }
+    }
+    ev = lv2_atom_sequence_next(ev);
+  }
+
+  *nevents = listsize;
+  return list;
+}
+
+void InputLV2::post()
+{
+}
diff --git a/src/input_lv2.h b/src/input_lv2.h
new file mode 100644
index 0000000..32e2fd8
--- /dev/null
+++ b/src/input_lv2.h
@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            input_lv2.h
+ *
+ *  Wed Jul 13 14:27:02 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_INPUT_LV2_H__
+#define __DRUMGIZMO_INPUT_LV2_H__
+
+#include <audioinputenginemidi.h>
+
+#include <lv2/lv2plug.in/ns/ext/atom/atom.h>
+
+class InputLV2 : public AudioInputEngineMidi {
+public:
+  InputLV2();
+  ~InputLV2();
+
+  bool init(Instruments &instruments);
+
+  void setParm(std::string parm, std::string value);
+
+  bool start();
+  void stop();
+
+  void pre();
+  event_t *run(size_t pos, size_t len, size_t *nevents);
+  void post();
+
+  LV2_Atom_Sequence *eventPort;
+
+private:
+  Instruments *instruments;
+};
+
+#endif/*__DRUMGIZMO_INPUT_LV2_H__*/
diff --git a/src/lv2.cc b/src/lv2.cc
new file mode 100644
index 0000000..d87665d
--- /dev/null
+++ b/src/lv2.cc
@@ -0,0 +1,235 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            lv2.cc
+ *
+ *  Wed Jul 13 13:50:33 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include <lv2/lv2plug.in/ns/lv2core/lv2.h>
+#include <lv2/lv2plug.in/ns/ext/atom/atom.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "lv2_gui.h"
+#include "lv2_instance.h"
+
+#include <hugin.hpp>
+
+#define DRUMGIZMO_URI "http://drumgizmo.org/lv2"
+#define NS_DG DRUMGIZMO_URI "/atom#"
+
+// Stuff to handle DrumGizmo* transmission from instance to GUI.
+static LV2_DrumGizmo_Descriptor dg_descriptor;
+
+static DrumGizmo *dg_get_pci(LV2_Handle instance)
+{
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+  return dglv2->dg;
+}
+
+LV2_State_Status
+dg_save(LV2_Handle                 instance,
+        LV2_State_Store_Function   store,
+        LV2_State_Handle           handle,
+        uint32_t                   flags,
+        const LV2_Feature *const * features)
+{
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+
+  if(!dglv2 || !dglv2->map || !dglv2->map->map) {
+    // Missing urid feature?
+    return  LV2_STATE_ERR_NO_FEATURE;
+  }
+
+  std::string config = dglv2->dg->configString();
+
+  // Backwards compatible fix for errornously stored '\0' byte in < v0.9.8.
+  // Remove when we reach v1.0
+  config += "\n";
+
+  store(handle,
+        dglv2->map->map(dglv2->map->handle, NS_DG "config"),
+        config.data(),
+        config.length(),
+        dglv2->map->map(dglv2->map->handle, LV2_ATOM__Chunk),
+        LV2_STATE_IS_POD | LV2_STATE_IS_PORTABLE);
+
+  return LV2_STATE_SUCCESS;
+}
+
+LV2_State_Status
+dg_restore(LV2_Handle                  instance,
+           LV2_State_Retrieve_Function retrieve,
+           LV2_State_Handle            handle,
+           uint32_t                    flags,
+           const LV2_Feature *const *  features)
+{
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+
+  if(!dglv2 || !dglv2->map || !dglv2->map->map) {
+    // Missing urid feature?
+    return  LV2_STATE_ERR_NO_FEATURE;
+  }
+
+  size_t size;
+  uint32_t type;
+
+  const char* data =
+    (const char*)retrieve(handle,
+                          dglv2->map->map(dglv2->map->handle, NS_DG "config"),
+                          &size, &type, &flags);
+
+  DEBUG(lv2, "Config string size: %d, data*: %p\n", (int)size, data);
+
+  if(data && size) {
+    std::string config;
+
+    // Fix for errornously stored '\0' byte in < v0.9.8.
+    // Remove when we reach v1.0
+    if(data[size - 1] == '\0') size--;
+
+    config.append(data, size);
+    dglv2->dg->setConfigString(config);
+  }
+
+  return LV2_STATE_SUCCESS;
+}
+
+static LV2_State_Interface dg_persist = {
+  dg_save,
+  dg_restore
+};
+
+LV2_Handle instantiate(const struct _LV2_Descriptor *descriptor,
+                       double sample_rate,
+                       const char *bundle_path,
+                       const LV2_Feature *const *features)
+{
+  DGLV2 *dglv2 = new DGLV2;
+
+  dglv2->map = NULL;
+  for (int i = 0 ; features[i] ; i++) {
+    if (!strcmp(features[i]->URI,  LV2_URID_URI "#map")) {
+      dglv2->map = (LV2_URID_Map*)features[i]->data;
+    }
+ }
+
+  dg_descriptor.get_pci = dg_get_pci;
+
+  dglv2->in = new InputLV2();
+  dglv2->out = new OutputLV2();
+
+  dglv2->buffer = NULL;
+  dglv2->buffer_size = 0;
+
+  dglv2->dg = new DrumGizmo(dglv2->out, dglv2->in);
+  dglv2->dg->setSamplerate(sample_rate);
+
+  return (LV2_Handle)dglv2;
+}
+
+void connect_port(LV2_Handle instance,
+                  uint32_t port,
+                  void *data_location)
+{
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+
+  if(port == 0) {// MIDI in
+    dglv2->in->eventPort = (LV2_Atom_Sequence*)data_location;
+  } else {// Audio Port
+    if(port - 1 < NUM_OUTPUTS) {
+      dglv2->out->outputPorts[port - 1].samples = (sample_t*)data_location;
+      dglv2->out->outputPorts[port - 1].size = 0;
+    }
+  }
+}
+
+void activate(LV2_Handle instance)
+{
+  // We don't really need to do anything here.
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+  (void)dglv2;
+}
+
+void run(LV2_Handle instance,
+         uint32_t sample_count)
+{
+  static size_t pos = 0;
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+
+  dglv2->dg->run(pos, dglv2->buffer, sample_count);
+
+  pos += sample_count;
+}
+
+void deactivate(LV2_Handle instance)
+{
+  // We don't really need to do anything here.
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+  dglv2->dg->stop();
+}
+
+void cleanup(LV2_Handle instance)
+{
+  DGLV2 *dglv2 = (DGLV2 *)instance;
+  delete dglv2->dg;
+  delete dglv2->in;
+  delete dglv2->out;
+}
+
+const void* extension_data(const char *uri)
+{
+  if(!strcmp(uri, PLUGIN_INSTANCE_URI)) return &dg_descriptor;
+  if(!strcmp(uri, LV2_STATE__interface)) return &dg_persist;
+  return NULL;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const LV2_Descriptor descriptor = {
+	DRUMGIZMO_URI,
+	instantiate,
+	connect_port,
+  activate,
+	run,
+  deactivate,
+	cleanup,
+	extension_data
+};
+
+LV2_SYMBOL_EXPORT
+const LV2_Descriptor* lv2_descriptor(uint32_t index)
+{
+	switch (index) {
+	case 0:
+		return &descriptor;
+	default:
+		return NULL;
+	}
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/lv2_event.h b/src/lv2_event.h
new file mode 100644
index 0000000..2c340ba
--- /dev/null
+++ b/src/lv2_event.h
@@ -0,0 +1,281 @@
+/*
+  LV2 Event Extension
+  Copyright 2008-2011 David Robillard <http://drobilla.net>
+  Copyright 2006-2007 Lars Luthman <lars.luthman@gmail.com>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef LV2_EVENT_H
+#define LV2_EVENT_H
+
+#define LV2_EVENT_URI "http://lv2plug.in/ns/ext/event"
+#define LV2_EVENT_AUDIO_STAMP 0
+
+#include <stdint.h>
+
+/**
+   @file event.h
+   C API for the LV2 Event extension <http://lv2plug.in/ns/ext/event>.
+ 
+   This extension is a generic transport mechanism for time stamped events
+   of any type (e.g. MIDI, OSC, ramps, etc). Each port can transport mixed
+   events of any type; the type of events and timestamps are defined by a URI
+   which is mapped to an integer by the host for performance reasons.
+ 
+   This extension requires the host to support the LV2 URI Map extension.
+   Any host which supports this extension MUST guarantee that any call to
+   the LV2 URI Map uri_to_id function with the URI of this extension as the
+   'map' argument returns a value within the range of uint16_t.
+*/
+
+/**
+   The best Pulses Per Quarter Note for tempo-based uint32_t timestamps.
+   Equal to 2^12 * 5 * 7 * 9 * 11 * 13 * 17, which is evenly divisble
+   by all integers from 1 through 18 inclusive, and powers of 2 up to 2^12.
+*/
+static const uint32_t LV2_EVENT_PPQN = 3136573440U;
+
+/**
+   An LV2 event (header only).
+ 
+   LV2 events are generic time-stamped containers for any type of event.
+   The type field defines the format of a given event's contents.
+ 
+   This struct defines the header of an LV2 event. An LV2 event is a single
+   chunk of POD (plain old data), usually contained in a flat buffer (see
+   LV2_EventBuffer below). Unless a required feature says otherwise, hosts may
+   assume a deep copy of an LV2 event can be created safely using a simple:
+ 
+   memcpy(ev_copy, ev, sizeof(LV2_Event) + ev->size);  (or equivalent)
+*/
+typedef struct {
+
+	/**
+	   The frames portion of timestamp. The units used here can optionally be
+	   set for a port (with the lv2ev:timeUnits property), otherwise this is
+	   audio frames, corresponding to the sample_count parameter of the LV2 run
+	   method (e.g. frame 0 is the first frame for that call to run).
+	*/
+	uint32_t frames;
+
+	/**
+	   The sub-frames portion of timestamp. The units used here can optionally
+	   be set for a port (with the lv2ev:timeUnits property), otherwise this is
+	   1/(2^32) of an audio frame.
+	*/
+	uint32_t subframes;
+
+	/**
+	   The type of this event, as a number which represents some URI
+	   defining an event type. This value MUST be some value previously
+	   returned from a call to the uri_to_id function defined in the LV2
+	   URI map extension (see lv2_uri_map.h).
+	   There are special rules which must be followed depending on the type
+	   of an event. If the plugin recognizes an event type, the definition
+	   of that event type will describe how to interpret the event, and
+	   any required behaviour. Otherwise, if the type is 0, this event is a
+	   non-POD event and lv2_event_unref MUST be called if the event is
+	   'dropped' (see above). Even if the plugin does not understand an event,
+	   it may pass the event through to an output by simply copying (and NOT
+	   calling lv2_event_unref). These rules are designed to allow for generic
+	   event handling plugins and large non-POD events, but with minimal hassle
+	   on simple plugins that "don't care" about these more advanced features.
+	*/
+	uint16_t type;
+
+	/**
+	   The size of the data portion of this event in bytes, which immediately
+	   follows. The header size (12 bytes) is not included in this value.
+	*/
+	uint16_t size;
+
+	/* size bytes of data follow here */
+
+} LV2_Event;
+
+
+/**
+   A buffer of LV2 events (header only).
+ 
+   Like events (which this contains) an event buffer is a single chunk of POD:
+   the entire buffer (including contents) can be copied with a single memcpy.
+   The first contained event begins sizeof(LV2_EventBuffer) bytes after the
+   start of this struct.
+ 
+   After this header, the buffer contains an event header (defined by struct
+   LV2_Event), followed by that event's contents (padded to 64 bits), followed
+   by another header, etc:
+ 
+   |       |       |       |       |       |       |
+   | | | | | | | | | | | | | | | | | | | | | | | | |
+   |FRAMES |SUBFRMS|TYP|LEN|DATA..DATA..PAD|FRAMES | ...
+*/
+typedef struct {
+
+	/**
+	   The contents of the event buffer. This may or may not reside in the
+	   same block of memory as this header, plugins must not assume either.
+	   The host guarantees this points to at least capacity bytes of allocated
+	   memory (though only size bytes of that are valid events).
+	*/
+	uint8_t* data;
+
+	/**
+	   The size of this event header in bytes (including everything).
+	 
+	   This is to allow for extending this header in the future without
+	   breaking binary compatibility. Whenever this header is copied,
+	   it MUST be done using this field (and NOT the sizeof this struct).
+	*/
+	uint16_t header_size;
+
+	/**
+	   The type of the time stamps for events in this buffer.
+	   As a special exception, '0' always means audio frames and subframes
+	   (1/UINT32_MAX'th of a frame) in the sample rate passed to instantiate.
+
+	   INPUTS: The host must set this field to the numeric ID of some URI
+	   defining the meaning of the frames/subframes fields of contained events
+	   (obtained by the LV2 URI Map uri_to_id function with the URI of this
+	   extension as the 'map' argument, see lv2_uri_map.h).  The host must
+	   never pass a plugin a buffer which uses a stamp type the plugin does not
+	   'understand'. The value of this field must never change, except when
+	   connect_port is called on the input port, at which time the host MUST
+	   have set the stamp_type field to the value that will be used for all
+	   subsequent run calls.
+	   
+	   OUTPUTS: The plugin may set this to any value that has been returned
+	   from uri_to_id with the URI of this extension for a 'map' argument.
+	   When connected to a buffer with connect_port, output ports MUST set this
+	   field to the type of time stamp they will be writing. On any call to
+	   connect_port on an event input port, the plugin may change this field on
+	   any output port, it is the responsibility of the host to check if any of
+	   these values have changed and act accordingly.
+	*/
+	uint16_t stamp_type;
+
+	/**
+	   The number of events in this buffer.
+
+	   INPUTS: The host must set this field to the number of events contained
+	   in the data buffer before calling run(). The plugin must not change
+	   this field.
+
+	   OUTPUTS: The plugin must set this field to the number of events it has
+	   written to the buffer before returning from run(). Any initial value
+	   should be ignored by the plugin.
+	*/
+	uint32_t event_count;
+
+	/**
+	   The size of the data buffer in bytes.
+	   This is set by the host and must not be changed by the plugin.
+	   The host is allowed to change this between run() calls.
+	*/
+	uint32_t capacity;
+
+	/**
+	   The size of the initial portion of the data buffer containing data.
+
+	   INPUTS: The host must set this field to the number of bytes used
+	   by all events it has written to the buffer (including headers)
+	   before calling the plugin's run().
+	   The plugin must not change this field.
+
+	   OUTPUTS: The plugin must set this field to the number of bytes
+	   used by all events it has written to the buffer (including headers)
+	   before returning from run().
+	   Any initial value should be ignored by the plugin.
+	*/
+	uint32_t size;
+
+} LV2_Event_Buffer;
+
+
+/**
+   Opaque pointer to host data.
+*/
+typedef void* LV2_Event_Callback_Data;
+
+
+/**
+   Non-POD events feature.
+ 
+   To support this feature the host must pass an LV2_Feature struct to the
+   plugin's instantiate method with URI "http://lv2plug.in/ns/ext/event"
+   and data pointed to an instance of this struct.  Note this feature
+   is not mandatory to support the event extension.
+*/
+typedef struct {
+
+	/**
+	   Opaque pointer to host data.
+	 
+	   The plugin MUST pass this to any call to functions in this struct.
+	   Otherwise, it must not be interpreted in any way.
+	*/
+	LV2_Event_Callback_Data callback_data;
+
+	/**
+	   Take a reference to a non-POD event.
+	 
+	   If a plugin receives an event with type 0, it means the event is a
+	   pointer to some object in memory and not a flat sequence of bytes
+	   in the buffer. When receiving a non-POD event, the plugin already
+	   has an implicit reference to the event. If the event is stored AND
+	   passed to an output, lv2_event_ref MUST be called on that event.
+	   If the event is only stored OR passed through, this is not necessary
+	   (as the plugin already has 1 implicit reference).
+	 
+	   @param event An event received at an input that will not be copied to
+	   an output or stored in any way.
+	   
+	   @param context The calling context. Like event types, this is a mapped
+	   URI, see lv2_context.h. Simple plugin with just a run() method should
+	   pass 0 here (the ID of the 'standard' LV2 run context). The host
+	   guarantees that this function is realtime safe iff @a context is
+	   realtime safe.
+	 
+	   PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
+	*/
+	uint32_t (*lv2_event_ref)(LV2_Event_Callback_Data callback_data,
+	                          LV2_Event*              event);
+
+	/**
+	   Drop a reference to a non-POD event.
+	 
+	   If a plugin receives an event with type 0, it means the event is a
+	   pointer to some object in memory and not a flat sequence of bytes
+	   in the buffer. If the plugin does not pass the event through to
+	   an output or store it internally somehow, it MUST call this function
+	   on the event (more information on using non-POD events below).
+	 
+	   @param event An event received at an input that will not be copied to an
+	   output or stored in any way.
+	   
+	   @param context The calling context. Like event types, this is a mapped
+	   URI, see lv2_context.h. Simple plugin with just a run() method should
+	   pass 0 here (the ID of the 'standard' LV2 run context). The host
+	   guarantees that this function is realtime safe iff @a context is
+	   realtime safe.
+	 
+	   PLUGINS THAT VIOLATE THESE RULES MAY CAUSE CRASHES AND MEMORY LEAKS.
+	*/
+	uint32_t (*lv2_event_unref)(LV2_Event_Callback_Data callback_data,
+	                            LV2_Event*              event);
+
+} LV2_Event_Feature;
+
+
+#endif /* LV2_EVENT_H */
diff --git a/src/lv2_gui.cc b/src/lv2_gui.cc
new file mode 100644
index 0000000..858e097
--- /dev/null
+++ b/src/lv2_gui.cc
@@ -0,0 +1,237 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            lv2.cc
+ *
+ *  Wed Jul 13 13:50:33 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "lv2_gui.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <lv2/lv2plug.in/ns/ext/instance-access/instance-access.h>
+#include <lv2/lv2plug.in/ns/extensions/ui/ui.h>
+
+#include "lv2_instance.h"
+
+// From: http://codesearch.google.com/#50sg5qT6WNE/src/lv2_ui_dssi.c
+// git://repo.or.cz/nekobee.git/src/lv2_ui_dssi.c
+
+#define DRUMGIZMO_UI_URI "http://drumgizmo.org/lv2-gui"
+
+#include <plugingui.h>
+
+/**
+ * When LV2_EXTERNAL_UI_URI UI is instantiated, the returned
+ * LV2UI_Widget handle must be cast to pointer to struct lv2_external_ui.
+ * UI is created in invisible state.
+ */
+struct lv2_external_ui
+{
+  /**
+   * Host calls this function regulary. UI library implementing the
+   * callback may do IPC or redraw the UI.
+   *
+   * @param _this_ the UI context
+   */
+  void (* run)(struct lv2_external_ui * _this_);
+
+  /**
+   * Host calls this function to make the plugin UI visible.
+   *
+   * @param _this_ the UI context
+   */
+  void (* show)(struct lv2_external_ui * _this_);
+
+  /**
+   * Host calls this function to make the plugin UI invisible again.
+   *
+   * @param _this_ the UI context
+   */
+  void (* hide)(struct lv2_external_ui * _this_);
+};
+
+/** UI extension suitable for out-of-process UIs */
+#define LV2_EXTERNAL_UI_URI "http://lv2plug.in/ns/extensions/ui#external"
+
+/**
+ * On UI instantiation, host must supply LV2_EXTERNAL_UI_URI
+ * feature. LV2_Feature::data must be pointer to struct lv2_external_ui_host. */
+struct lv2_external_ui_host
+{
+  /**
+   * Callback that plugin UI will call
+   * when UI (GUI window) is closed by user.
+   * This callback wil; be called during execution of lv2_external_ui::run()
+   * (i.e. not from background thread).
+   *
+   * After this callback is called, UI is defunct. Host must call
+   * LV2UI_Descriptor::cleanup(). If host wants to make the UI visible
+   * again UI must be reinstantiated.
+   *
+   * @param controller Host context associated with plugin UI, as
+   * supplied to LV2UI_Descriptor::instantiate()
+   */
+  void (* ui_closed)(LV2UI_Controller controller);
+
+  /**
+   * Optional (may be NULL) "user friendly" identifier which the UI
+   * may display to allow a user to easily associate this particular
+   * UI instance with the correct plugin instance as it is represented
+   * by the host (e.g. "track 1" or "channel 4").
+   *
+   * If supplied by host, the string will be referenced only during
+   * LV2UI_Descriptor::instantiate()
+   */
+  const char * plugin_human_id;
+};
+
+struct DG_GUI {
+  struct lv2_external_ui virt;
+
+  LV2_Handle instance_handle;
+  LV2_Extension_Data_Feature *data_access;
+  DrumGizmo *instance;
+  LV2UI_Controller controller;
+
+  GUI::PluginGUI *gui;
+  struct lv2_external_ui_host *ui_host_ptr;
+};
+
+static void ui_run(struct lv2_external_ui * _this_)
+{
+  struct DG_GUI *dggui = (struct DG_GUI *)_this_;
+  dggui->gui->processEvents();
+}
+
+static void ui_show(struct lv2_external_ui * _this_)
+{
+  struct DG_GUI *dggui = (struct DG_GUI *)_this_;
+  dggui->gui->show();
+}
+
+static void ui_hide(struct lv2_external_ui * _this_)
+{
+  struct DG_GUI *dggui = (struct DG_GUI *)_this_;
+  if(dggui->gui) dggui->gui->hide();
+}
+
+static void closeHandler(void *ptr)
+{
+  struct DG_GUI *gui = (struct DG_GUI *)ptr;
+
+  if(gui->ui_host_ptr && gui->ui_host_ptr->ui_closed) {
+    gui->ui_host_ptr->ui_closed(gui->controller);
+  }
+
+  delete gui->gui;
+  gui->gui = NULL;
+}
+
+static LV2UI_Handle ui_instantiate(const struct _LV2UI_Descriptor * descriptor,
+                                   const char * plugin_uri,
+                                   const char * bundle_path,
+                                   LV2UI_Write_Function write_function,
+                                   LV2UI_Controller controller,
+                                   LV2UI_Widget * widget,
+                                   const LV2_Feature * const * features)
+{
+  printf("ui_instantiate\n");
+
+  struct DG_GUI* pt = new struct DG_GUI;
+
+  pt->ui_host_ptr = NULL;
+  pt->controller = controller;
+
+  while (*features != NULL) {
+    std::string uri = (*features)->URI;
+    void *data = (*features)->data;
+
+    printf("DGUI: feature: %s\n", uri.c_str());
+
+    if(uri == LV2_INSTANCE_ACCESS_URI) {
+      pt->instance_handle = data;
+    }
+
+    if(uri == LV2_DATA_ACCESS_URI) {
+      pt->data_access = (LV2_Extension_Data_Feature *)data;
+    }
+
+    if(uri == LV2_EXTERNAL_UI_URI) {
+      pt->ui_host_ptr = (struct lv2_external_ui_host *)data;
+    }
+    features++;
+  }
+
+  LV2_DrumGizmo_Descriptor *dgd =
+    (LV2_DrumGizmo_Descriptor *)(*pt->data_access->data_access)(PLUGIN_INSTANCE_URI);
+
+  pt->instance = dgd->get_pci(pt->instance_handle);
+  pt->virt.run = ui_run;
+  pt->virt.show = ui_show;
+  pt->virt.hide = ui_hide;
+  pt->gui = new GUI::PluginGUI();
+  pt->gui->setWindowClosedCallback(closeHandler, pt);
+
+  *widget = (LV2UI_Widget)pt;
+
+  return pt;
+}
+
+static void ui_cleanup(LV2UI_Handle ui)
+{
+  struct DG_GUI* pt = (struct DG_GUI*)ui;
+  delete pt->gui;
+  pt->gui = NULL;
+  delete pt;
+}
+
+static void ui_port_event(LV2UI_Handle ui,
+                          uint32_t port_index,
+                          uint32_t buffer_size,
+                          uint32_t format,
+                          const void * buffer)
+{
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static LV2UI_Descriptor descriptor = {
+  DRUMGIZMO_UI_URI,
+  ui_instantiate,
+  ui_cleanup,
+  ui_port_event,
+  NULL
+};
+
+const LV2UI_Descriptor *lv2ui_descriptor(uint32_t index)
+{
+  if(index == 0) return &descriptor;
+  return NULL;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/lv2_gui.h b/src/lv2_gui.h
new file mode 100644
index 0000000..2857445
--- /dev/null
+++ b/src/lv2_gui.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            lv2_gui.h
+ *
+ *  Fri Oct 21 10:48:53 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_LV2_GUI_H__
+#define __DRUMGIZMO_LV2_GUI_H__
+
+#include <lv2/lv2plug.in/ns/lv2core/lv2.h>
+#include <lv2/lv2plug.in/ns/ext/data-access/data-access.h>
+
+#define PLUGIN_INSTANCE_URI "http://drumgizmo.org/ns/drumgizmo-plugin-instance"
+
+class DrumGizmo;
+struct LV2_DrumGizmo_Descriptor {
+  DrumGizmo *(*get_pci)(LV2_Handle instance);
+};
+
+#endif/*__DRUMGIZMO_LV2_GUI_H__*/
diff --git a/src/lv2_instance.h b/src/lv2_instance.h
new file mode 100644
index 0000000..e050e22
--- /dev/null
+++ b/src/lv2_instance.h
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            lv2_instance.h
+ *
+ *  Sun Nov 20 15:27:41 CET 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_LV2_INSTANCE_H__
+#define __DRUMGIZMO_LV2_INSTANCE_H__
+
+#include <lv2/lv2plug.in/ns/lv2core/lv2.h>
+#include <lv2/lv2plug.in/ns/ext/state/state.h>
+#include <lv2/lv2plug.in/ns/ext/urid/urid.h>
+
+#include "input_lv2.h"
+#include "output_lv2.h"
+
+#include <drumgizmo.h>
+
+typedef struct {
+  InputLV2 *in;
+  OutputLV2 *out;
+  DrumGizmo *dg;
+  sample_t *buffer;
+  size_t buffer_size;
+  LV2_URID_Map* map;
+} DGLV2;
+
+#endif/*__DRUMGIZMO_LV2_INSTANCE_H__*/
diff --git a/src/manifest.ttl b/src/manifest.ttl
new file mode 100644
index 0000000..65a8953
--- /dev/null
+++ b/src/manifest.ttl
@@ -0,0 +1,7 @@
+@prefix lv2: <http://lv2plug.in/ns/lv2core#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+<http://drumgizmo.org/lv2>
+	a lv2:Plugin ;
+	lv2:binary <drumgizmo.so> ;
+	rdfs:seeAlso <drumgizmo.ttl> .
diff --git a/src/message.h b/src/message.h
new file mode 100644
index 0000000..07b0300
--- /dev/null
+++ b/src/message.h
@@ -0,0 +1,121 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            message.h
+ *
+ *  Wed Mar 20 15:50:57 CET 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_MESSAGE_H__
+#define __DRUMGIZMO_MESSAGE_H__
+
+#include <string>
+
+class MessageHandler;
+
+class Message {
+public:
+  typedef enum {
+    // Engine -> GUI Messages:
+    LoadStatus, // Signal GUI the current load status.
+    LoadStatusMidimap, // Signal GUI the current load status of the midimap.
+
+    // GUI -> Engine, Engine -> Engine Messages:
+    LoadDrumKit, // Signal engine to load drumkit.
+    LoadMidimap, // Signal engine to load midimap.
+    EngineSettingsMessage, // Request or receive engine settings.
+    ChangeSettingMessage, // Update named setting in engine.
+  } type_t;
+
+  typedef enum {
+    NormalProcessing, // Just add to the queue
+    FilterMultiple, // Ignore top message if it has the same type.
+    // SyncWait, // Block the send call until the message has been handled by the receiver.
+  } processing_mode_t;
+
+  virtual ~Message() {}
+  virtual type_t type() = 0;
+  virtual processing_mode_t processing_mode() { return NormalProcessing; }
+};
+
+class LoadStatusMessage : public Message {
+public:
+  type_t type() { return Message::LoadStatus; }
+  processing_mode_t processing_mode() { return FilterMultiple; }
+  unsigned int number_of_files;
+  unsigned int numer_of_files_loaded;
+  std::string current_file;
+};
+
+class LoadStatusMessageMidimap : public Message {
+public:
+  type_t type() { return Message::LoadStatusMidimap; }
+  bool success;
+};
+
+class LoadDrumKitMessage : public Message {
+public:
+  type_t type() { return Message::LoadDrumKit; }
+  std::string drumkitfile;
+};
+
+class LoadMidimapMessage : public Message {
+public:
+  type_t type() { return Message::LoadMidimap; }
+  std::string midimapfile;
+};
+
+class EngineSettingsMessage : public Message {
+public:
+  type_t type() { return Message::EngineSettingsMessage; }
+  std::string midimapfile;
+  bool midimap_loaded;
+
+  std::string drumkitfile;
+  bool drumkit_loaded;
+
+  float enable_velocity_modifier;
+  float velocity_modifier_falloff;
+  float velocity_modifier_weight;
+  float enable_velocity_randomiser;
+  float velocity_randomiser_weight;
+};
+
+class ChangeSettingMessage : public Message {
+public:
+  typedef enum {
+    enable_velocity_modifier,
+    velocity_modifier_weight,
+    velocity_modifier_falloff,
+  } setting_name_t;
+
+  ChangeSettingMessage(setting_name_t n, float v) {
+    name = n;
+    value = v;
+  }
+
+  type_t type() { return Message::ChangeSettingMessage; }
+
+  setting_name_t name;
+  float value;
+};
+
+#endif/*__DRUMGIZMO_MESSAGE_H__*/
diff --git a/src/messagehandler.cc b/src/messagehandler.cc
new file mode 100644
index 0000000..52a89a5
--- /dev/null
+++ b/src/messagehandler.cc
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            messagehandler.cc
+ *
+ *  Fri Jun 14 20:30:43 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "messagehandler.h"
+
+#include <hugin.hpp>
+
+#include "messagereceiver.h"
+
+// Global messagehandler:
+MessageHandler msghandler;
+
+MessageHandler::MessageHandler()
+{
+}
+
+void MessageHandler::addReceiver(message_receiver_id_t id,
+                                 MessageReceiver *receiver)
+{
+  MutexAutolock l(mutex);
+
+  receivers[id] = receiver;
+}
+
+void MessageHandler::removeReceiver(MessageReceiver *receiver)
+{
+  MutexAutolock l(mutex);
+
+  std::map<message_receiver_id_t, MessageReceiver *>::iterator i =
+    receivers.begin();
+  while(i != receivers.end()) {
+    if(i->second == receiver) {
+      receivers.erase(i);
+      break;
+    }
+    i++;
+  }
+}
+
+bool MessageHandler::sendMessage(message_receiver_id_t id, Message* msg)
+{
+  MutexAutolock l(mutex);
+
+  if(receivers.find(id) == receivers.end()) {
+    //WARN(msghandler, "Could not find id %d\n", id);
+    delete msg;
+    return false;
+  }
+
+  //DEBUG(msghandler, "Sending message to id %d\n", id);
+
+  MessageReceiver *receiver = receivers[id];
+  /* // This code causes sporadic segfaults on windows.
+  if(msg->processing_mode() == Message::FilterMultiple) {
+    Message *pmsg;
+    MutexAutolock lock(receiver->message_mutex); // Make peek/receive atomic.
+    while( (pmsg = receiver->peekMessage()) != NULL) {
+      if(pmsg->type() != msg->type()) break;
+      // Remove all old messages with same type.
+      delete receiver->receiveMessage();
+    }
+  }
+  */
+  receiver->sendMessage(msg);
+  return true;
+}
diff --git a/src/messagehandler.h b/src/messagehandler.h
new file mode 100644
index 0000000..9812777
--- /dev/null
+++ b/src/messagehandler.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            messagehandler.h
+ *
+ *  Fri Jun 14 20:30:43 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_MESSAGEHANDLER_H__
+#define __DRUMGIZMO_MESSAGEHANDLER_H__
+
+#include <map>
+
+#include "message.h"
+#include "mutex.h"
+
+typedef enum {
+  MSGRCV_ENGINE = 1,
+  MSGRCV_UI = 2,
+  MSGRCV_LOADER = 3,
+} message_receiver_id_t;
+
+class MessageReceiver;
+
+class MessageHandler {
+public:
+  MessageHandler();
+
+  void addReceiver(message_receiver_id_t id, MessageReceiver *receiver);
+  void removeReceiver(MessageReceiver *receiver);
+
+  /**
+   * Send Message to receiver with specified id.
+   * @return Return true if id is registered. Return false if id is not
+   * currently registered.
+   */
+  bool sendMessage(message_receiver_id_t id, Message* msg);
+
+private:
+  std::map<message_receiver_id_t, MessageReceiver *> receivers;
+
+  Mutex mutex;
+};
+
+// Global MessageHandler;
+extern MessageHandler msghandler;
+
+#endif/*__DRUMGIZMO_MESSAGEHANDLER_H__*/
diff --git a/src/messagereceiver.cc b/src/messagereceiver.cc
new file mode 100644
index 0000000..a24482b
--- /dev/null
+++ b/src/messagereceiver.cc
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            messagereceiver.cc
+ *
+ *  Sun Jun 16 12:09:06 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "messagereceiver.h"
+
+#include <hugin.hpp>
+
+MessageReceiver::MessageReceiver(message_receiver_id_t id)
+{
+  msghandler.addReceiver(id, this);
+}
+
+MessageReceiver::~MessageReceiver()
+{
+  msghandler.removeReceiver(this);
+}
+
+void MessageReceiver::sendMessage(Message *msg)
+{
+  MutexAutolock l(message_mutex);
+
+  message_queue.push_back(msg);
+}
+
+Message *MessageReceiver::receiveMessage()
+{
+  Message *msg = NULL;
+  if(message_queue.size()) {
+    msg = message_queue.front();
+    message_queue.pop_front();
+  }
+  return msg;
+}
+
+Message *MessageReceiver::peekMessage()
+{
+  Message *msg = NULL;
+  if(message_queue.size()) {
+    msg = message_queue.front();
+  }
+  return msg;
+}
+
+void MessageReceiver::handleMessages(size_t max)
+{
+  MutexAutolock l(message_mutex);
+  bool process_all = false;
+  if(max == 0) process_all = true;
+
+  while((process_all || max--) && peekMessage()) {
+    Message *msg = receiveMessage();
+    handleMessage(msg);
+    delete msg;
+  }
+}
diff --git a/src/messagereceiver.h b/src/messagereceiver.h
new file mode 100644
index 0000000..2794091
--- /dev/null
+++ b/src/messagereceiver.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            messagereceiver.h
+ *
+ *  Sun Jun 16 12:09:06 CEST 2013
+ *  Copyright 2013 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_MESSAGERECEIVER_H__
+#define __DRUMGIZMO_MESSAGERECEIVER_H__
+
+#include <list>
+
+#include "mutex.h"
+#include "message.h"
+#include "messagehandler.h"
+
+class MessageReceiver {
+  friend class MessageHandler;
+public:
+  MessageReceiver(message_receiver_id_t id);
+  ~MessageReceiver();
+
+  /**
+   * Receive message from the message queue.
+   */
+  Message *receiveMessage();
+
+  /**
+   * Receive message from the message queue without removing it.
+   */
+  Message *peekMessage();
+
+  /**
+   * Add a message to the message queue.
+   */
+  void sendMessage(Message *msg);
+
+  /**
+   * Handle messages from the event queue.
+   * @param max_number_of_events the maximum number of events to be handled in
+   * this call. 0 means all.
+   */
+  void handleMessages(size_t max_number_of_events = 0);
+
+  /**
+   * Handler to be implemented in child classes.
+   * Handles a single event.
+   */
+  virtual void handleMessage(Message *msg) = 0;
+
+private:
+  Mutex message_mutex;
+  std::list<Message *> message_queue;
+};
+
+#endif/*__DRUMGIZMO_MESSAGERECEIVER_H__*/
diff --git a/src/midimapparser.cc b/src/midimapparser.cc
new file mode 100644
index 0000000..9d30a05
--- /dev/null
+++ b/src/midimapparser.cc
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            midimapparser.cc
+ *
+ *  Mon Aug  8 16:55:30 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "midimapparser.h"
+
+MidiMapParser::MidiMapParser(std::string file)
+{
+  fd = fopen(file.c_str(), "r");
+}
+
+MidiMapParser::~MidiMapParser()
+{
+  if(fd) fclose(fd);
+}
+
+void MidiMapParser::startTag(std::string name, attr_t attr)
+{
+  if(name == "map") {
+    if(attr.find("note") != attr.end() && attr.find("instr") != attr.end()) {
+      midimap[atoi(attr["note"].c_str())] = attr["instr"];
+    }
+  }
+}
+
+int MidiMapParser::readData(char *data, size_t size)
+{
+  if(!fd) return -1;
+  return fread(data, 1, size, fd);
+}
diff --git a/src/midimapparser.h b/src/midimapparser.h
new file mode 100644
index 0000000..98ab886
--- /dev/null
+++ b/src/midimapparser.h
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            midimapparser.h
+ *
+ *  Mon Aug  8 16:55:30 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_MIDIMAPPARSER_H__
+#define __DRUMGIZMO_MIDIMAPPARSER_H__
+
+#include <stdio.h>
+
+#include "saxparser.h"
+
+#include "midimapper.h"
+
+class MidiMapParser : public SAXParser {
+public:
+  MidiMapParser(std::string file);
+  ~MidiMapParser();
+
+  void startTag(std::string name, attr_t attr);
+
+  midimap_t midimap;
+
+protected:
+  int readData(char *data, size_t size);
+
+private:
+  FILE *fd;
+};
+
+#endif/*__DRUMGIZMO_MIDIMAPPARSER_H__*/
diff --git a/src/midimapper.cc b/src/midimapper.cc
new file mode 100644
index 0000000..d4ff94e
--- /dev/null
+++ b/src/midimapper.cc
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            midimapper.cc
+ *
+ *  Mon Jul 21 15:24:08 CEST 2008
+ *  Copyright 2008 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "midimapper.h"
+
+int MidiMapper::lookup(int note)
+{
+  if(midimap.find(note) == midimap.end()) return -1;
+  std::string instr = midimap[note];
+  if(instrmap.find(instr) == instrmap.end()) return -1;
+  return instrmap[instr];
+}
+
+void MidiMapper::clear()
+{
+  midimap.clear();
+  instrmap.clear();
+}
diff --git a/src/midimapper.h b/src/midimapper.h
new file mode 100644
index 0000000..7439c4b
--- /dev/null
+++ b/src/midimapper.h
@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            midimapper.h
+ *
+ *  Mon Jul 21 15:24:07 CEST 2008
+ *  Copyright 2008 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_MIDIMAPPER_H__
+#define __DRUMGIZMO_MIDIMAPPER_H__
+
+#include <map>
+#include <string>
+
+typedef std::map<int, std::string> midimap_t;
+typedef std::map<std::string, int> instrmap_t;
+
+class MidiMapper {
+public:
+  void clear();
+
+  int lookup(int note);
+
+  instrmap_t instrmap;
+  midimap_t midimap;
+};
+
+#endif/*__DRUMGIZMO_MIDIMAPPER_H__*/
diff --git a/src/mutex.cc b/src/mutex.cc
new file mode 100644
index 0000000..22d59a6
--- /dev/null
+++ b/src/mutex.cc
@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ *            mutex.cc
+ *
+ *  Thu Nov 12 10:51:32 CET 2009
+ *  Copyright 2009 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of Pracro.
+ *
+ *  Pracro is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Pracro is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Pracro; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "mutex.h"
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+struct mutex_private_t {
+#ifdef WIN32
+  HANDLE mutex; 
+#else
+  pthread_mutex_t mutex;
+#endif
+};
+
+Mutex::Mutex()
+{
+  prv = new struct mutex_private_t();
+#ifdef WIN32
+  prv->mutex = CreateMutex(NULL,  // default security attributes
+                           FALSE, // initially not owned
+                           NULL); // unnamed mutex
+#else
+  pthread_mutex_init (&prv->mutex, NULL);
+#endif
+}
+
+Mutex::~Mutex()
+{
+#ifdef WIN32
+  CloseHandle(prv->mutex);
+#else
+  pthread_mutex_destroy(&prv->mutex);
+#endif
+
+  if(prv) delete prv;
+}
+
+void Mutex::lock()
+{
+#ifdef WIN32
+  WaitForSingleObject(prv->mutex, // handle to mutex
+                      INFINITE);  // no time-out interval
+#else
+  pthread_mutex_lock(&prv->mutex);
+#endif
+}
+
+void Mutex::unlock()
+{
+#ifdef WIN32
+  ReleaseMutex(prv->mutex);
+#else
+  pthread_mutex_unlock(&prv->mutex);
+#endif
+}
+
+MutexAutolock::MutexAutolock(Mutex &m)
+  : mutex(m)
+{
+  mutex.lock();
+}
+
+MutexAutolock::~MutexAutolock()
+{
+  mutex.unlock();
+}
+
+#ifdef TEST_MUTEX
+//deps:
+//cflags: $(PTHREAD_CFLAGS)
+//libs: $(PTHREAD_LIBS)
+#include <test.h>
+
+#include <unistd.h>
+
+volatile int cnt = 0;
+
+static void* thread_run(void *data)
+{
+  Mutex *mutex = (Mutex*)data;
+  mutex->lock();
+  cnt++;
+  mutex->unlock();
+  return NULL;
+}
+
+TEST_BEGIN;
+
+Mutex mutex;
+
+mutex.lock();
+TEST_FALSE(mutex.trylock(), "Testing if trylock works negative.");
+mutex.unlock();
+TEST_TRUE(mutex.trylock(), "Testing if trylock works positive.");
+mutex.unlock();
+
+mutex.lock();
+
+pthread_attr_t attr;
+pthread_t tid;
+pthread_attr_init(&attr);
+pthread_create(&tid, &attr, thread_run, &mutex);
+
+sleep(1);
+TEST_EQUAL_INT(cnt, 0, "Testing if lock prevent cnt from increasing.");
+mutex.unlock();
+
+sleep(1);
+TEST_EQUAL_INT(cnt, 1, "Testing if unlock makes cnt increase.");
+
+pthread_join(tid, NULL);
+pthread_attr_destroy(&attr);
+
+{
+  TEST_TRUE(mutex.trylock(), "Testing if autolock has not yet locked the mutex.");
+  mutex.unlock();
+  MutexAutolock mlock(mutex);
+  TEST_FALSE(mutex.trylock(), "Testing if autolock worked.");
+}
+
+TEST_TRUE(mutex.trylock(), "Testing if autolock has released the lock on the mutex.");
+mutex.unlock();
+
+TEST_END;
+
+#endif/*TEST_MUTEX*/
diff --git a/src/mutex.h b/src/mutex.h
new file mode 100644
index 0000000..11704d4
--- /dev/null
+++ b/src/mutex.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ *            mutex.h
+ *
+ *  Thu Nov 12 10:51:32 CET 2009
+ *  Copyright 2009 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of Pracro.
+ *
+ *  Pracro is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Pracro is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Pracro; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __PRACRO_MUTEX_H__
+#define __PRACRO_MUTEX_H__
+
+struct mutex_private_t;
+
+class Mutex {
+public:
+  Mutex();
+  ~Mutex();
+
+  bool trylock();
+  void lock();
+  void unlock();
+
+private:
+  struct mutex_private_t* prv;
+};
+
+class MutexAutolock {
+public:
+  MutexAutolock(Mutex &mutex);
+  ~MutexAutolock();
+
+private:
+  Mutex &mutex;
+};
+
+#endif/*__PRACRO_MUTEX_H__*/
diff --git a/src/nolocale.h b/src/nolocale.h
new file mode 100644
index 0000000..816dd9c
--- /dev/null
+++ b/src/nolocale.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            nolocale.h
+ *
+ *  Fri Feb 13 12:48:10 CET 2015
+ *  Copyright 2015 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_NOLOCALE_H__
+#define __DRUMGIZMO_NOLOCALE_H__
+
+#include <locale.h>
+#include <stdarg.h>
+
+static inline double atof_nol(const char *nptr)
+{
+	double res;
+
+  const char *locale = setlocale(LC_NUMERIC, "C");
+
+  res = atof(nptr);
+
+  setlocale(LC_NUMERIC, locale);
+
+	return res;
+}
+
+static inline int sprintf_nol(char *str, const char *format, ...)
+{
+  int ret;
+
+  const char *locale = setlocale(LC_NUMERIC, "C");
+
+  va_list vl;
+  va_start(vl, format);
+  ret = vsprintf(str, format, vl);
+  va_end(vl);
+
+  setlocale(LC_NUMERIC, locale);
+
+  return ret;
+}
+
+static inline int snprintf_nol(char *str, size_t size, const char *format, ...)
+{
+  int ret;
+
+  const char *locale = setlocale(LC_NUMERIC, "C");
+
+  va_list vl;
+  va_start(vl, format);
+  ret = vsnprintf(str, size, format, vl);
+  va_end(vl);
+
+  setlocale(LC_NUMERIC, locale);
+
+  return ret;
+}
+
+#endif/*__DRUMGIZMO_NOLOCALE_H__*/
diff --git a/src/output_lv2.cc b/src/output_lv2.cc
new file mode 100644
index 0000000..09999cb
--- /dev/null
+++ b/src/output_lv2.cc
@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            output_lv2.cc
+ *
+ *  Wed Jul 13 14:27:06 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "output_lv2.h"
+
+#include <string.h>
+
+OutputLV2::OutputLV2()
+{
+  for(size_t i = 0; i < NUM_OUTPUTS; i++) {
+    outputPorts[i].size = 0;
+    outputPorts[i].samples = NULL;
+  }
+}
+
+OutputLV2::~OutputLV2()
+{
+}
+
+bool OutputLV2::init(Channels channels)
+{
+  return true;
+}
+
+void OutputLV2::setParm(std::string parm, std::string value)
+{
+}
+
+bool OutputLV2::start()
+{
+  return true;
+}
+
+void OutputLV2::stop()
+{
+}
+
+void OutputLV2::pre(size_t nsamples)
+{
+}
+
+void OutputLV2::run(int ch, sample_t *samples, size_t nsamples)
+{
+  if(ch < NUM_OUTPUTS) {
+    if(outputPorts[ch].samples) {
+      memcpy(outputPorts[ch].samples, samples, nsamples * sizeof(sample_t));
+    }
+  }
+}
+
+void OutputLV2::post(size_t nsamples)
+{
+}
+
+sample_t *OutputLV2::getBuffer(int ch)
+{
+  if(ch < NUM_OUTPUTS) return outputPorts[ch].samples;
+  return NULL;
+}
diff --git a/src/output_lv2.h b/src/output_lv2.h
new file mode 100644
index 0000000..a3a2555
--- /dev/null
+++ b/src/output_lv2.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            output_lv2.h
+ *
+ *  Wed Jul 13 14:27:06 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_OUTPUT_LV2_H__
+#define __DRUMGIZMO_OUTPUT_LV2_H__
+
+#include <audiooutputengine.h>
+
+#define NUM_OUTPUTS 64
+
+class OutputPort {
+public:
+  size_t size;
+  sample_t *samples;
+};
+
+class OutputLV2 : public AudioOutputEngine {
+public:
+  OutputLV2();
+  ~OutputLV2();
+
+  bool init(Channels channels);
+
+  void setParm(std::string parm, std::string value);
+
+  bool start();
+  void stop();
+
+  void pre(size_t nsamples);
+  void run(int ch, sample_t *samples, size_t nsamples);
+  void post(size_t nsamples);
+
+  sample_t *getBuffer(int c);
+
+  OutputPort outputPorts[NUM_OUTPUTS];
+};
+
+#endif/*__DRUMGIZMO_OUTPUT_LV2_H__*/
diff --git a/src/path.cc b/src/path.cc
new file mode 100644
index 0000000..1b4ede3
--- /dev/null
+++ b/src/path.cc
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            path.cc
+ *
+ *  Tue May  3 14:42:47 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "path.h"
+
+#ifndef __MINGW32__
+#include <libgen.h>
+#endif/*__MINGW32__*/
+
+#include <string.h>
+#include <stdlib.h>
+
+std::string getPath(std::string file)
+{
+  std::string p;
+#ifndef __MINGW32__
+  char *b = strdup(file.c_str());
+  p = dirname(b);
+  free(b);
+#else
+  char drive[_MAX_DRIVE];
+  char dir[_MAX_DIR];
+  _splitpath(file.c_str(), drive, dir, NULL, NULL);
+  p = std::string(drive) + dir;
+#endif
+
+  return p;
+}
diff --git a/src/path.h b/src/path.h
new file mode 100644
index 0000000..bdad0a5
--- /dev/null
+++ b/src/path.h
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            path.h
+ *
+ *  Tue May  3 14:42:46 CEST 2011
+ *  Copyright 2011 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_PATH_H__
+#define __DRUMGIZMO_PATH_H__
+
+#include <string>
+
+std::string getPath(std::string file);
+
+#endif/*__DRUMGIZMO_PATH_H__*/
diff --git a/src/saxparser.cc b/src/saxparser.cc
new file mode 100644
index 0000000..1bd98a8
--- /dev/null
+++ b/src/saxparser.cc
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            saxparser.cc
+ *
+ *  Tue Jul 22 16:26:22 CEST 2008
+ *  Copyright 2008 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "saxparser.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <hugin.hpp>
+
+static void character_hndl(void *p, const XML_Char *s, int len)
+{
+  SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+  std::string chars;
+  chars.append(s, len);
+  parser->characterData(chars);
+}
+
+static void start_hndl(void *p, const char *el, const char **attr)
+{
+  SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+
+  // Convert to comfy C++ values...
+  std::string name = el;
+  std::map< std::string, std::string > attributes;
+
+  while(*attr) {
+    std::string at_name = *attr;
+    attr++;
+    std::string at_value = *attr;
+    attr++;
+
+    attributes.insert(make_pair(at_name, at_value));
+  }
+
+  parser->startTag(name, attributes);
+}
+
+static void end_hndl(void *p, const char *el)
+{
+  SAXParser *parser = (SAXParser*)XML_GetUserData(p);
+  std::string name = el;
+  parser->endTag(name);
+}
+
+
+SAXParser::SAXParser()
+{
+  p = XML_ParserCreate(NULL);
+  if(!p) {
+    fprintf(stderr, "Couldn't allocate memory for parser\n");
+    // throw Exception(...);
+    return;
+  }
+
+  XML_SetUserData(p, this);
+  XML_UseParserAsHandlerArg(p);
+  XML_SetElementHandler(p, start_hndl, end_hndl);
+  XML_SetCharacterDataHandler(p, character_hndl);
+}
+
+SAXParser::~SAXParser()
+{
+  XML_ParserFree(p);
+}
+
+int SAXParser::parse()
+{
+  DEBUG(sax, "parse()\n");
+
+  char buf[32];
+  int len;
+  
+  do {
+    len = readData(buf, sizeof(buf) - 1);
+    if(len == -1) {
+      parseError((char*)"", 0, "Could not read data", 0);
+      return 1;
+    }
+    if(!XML_Parse(p, buf, len, len == 0)) {
+      parseError(buf, len, XML_ErrorString(XML_GetErrorCode(p)),
+                 (int)XML_GetCurrentLineNumber(p));
+      return 1;
+    }
+
+    memset(buf, 0, sizeof(buf));
+  } while(len);
+
+  return 0;
+}
+
+int SAXParser::parse(std::string buffer)
+{
+  DEBUG(sax, "parse(buffer %d bytes)\n", (int)buffer.length());
+
+  if(!XML_Parse(p, buffer.c_str(), buffer.length(), true)) {
+    parseError((char*)buffer.c_str(), buffer.length(),
+               XML_ErrorString(XML_GetErrorCode(p)),
+               (int)XML_GetCurrentLineNumber(p));
+    return 1;
+  }
+
+  return 0;
+}
+
+void SAXParser::parseError(char *buf, size_t len, std::string error, int lineno)
+{
+  fprintf(stderr, "SAXParser error at line %d: %s\n", lineno, error.c_str());
+  fprintf(stderr, "\tBuffer %u bytes: [", (int)len);
+  if(fwrite(buf, len, 1, stderr) != len) {}
+  fprintf(stderr, "]\n");
+  fflush(stderr);
+}
diff --git a/src/saxparser.h b/src/saxparser.h
new file mode 100644
index 0000000..aff90d7
--- /dev/null
+++ b/src/saxparser.h
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            saxparser.h
+ *
+ *  Tue Jul 22 16:26:21 CEST 2008
+ *  Copyright 2008 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __DRUMGIZMO_SAXPARSER_H__
+#define __DRUMGIZMO_SAXPARSER_H__
+
+#include <string>
+#include <map>
+#include <expat.h>
+
+typedef std::map< std::string, std::string> attr_t;
+
+class SAXParser {
+public:
+  SAXParser();
+  virtual ~SAXParser();
+
+  int parse();
+  int parse(std::string buffer);
+  
+  virtual void characterData(std::string &data) {}
+  virtual void startTag(std::string name, attr_t attr) {}
+  virtual void endTag(std::string name) {}
+
+  virtual void parseError(char *buf, size_t len, std::string error, int lineno);
+
+protected:
+  virtual int readData(char *data, size_t size) { return 0; }
+
+private:
+  XML_Parser p;
+};
+
+#endif/*__DRUMGIZMO_SAXPARSER_H__*/
diff --git a/src/semaphore.cc b/src/semaphore.cc
new file mode 100644
index 0000000..47ce8e0
--- /dev/null
+++ b/src/semaphore.cc
@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            semaphore.cc
+ *
+ *  Sat Oct  8 17:44:13 CEST 2005
+ *  Copyright  2005 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of Pracro.
+ *
+ *  Pracro is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Pracro is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Pracro; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "semaphore.h"
+
+#include <hugin.hpp>
+
+#ifdef WIN32
+#include <windows.h>
+#else
+// Make sure we don't include /this/ file...
+#include <../include/semaphore.h>
+#endif
+
+struct semaphore_private_t {
+#ifdef WIN32
+  HANDLE semaphore; 
+#else
+  sem_t semaphore;
+#endif
+};
+
+Semaphore::Semaphore(const char *name)
+{
+  this->name = name;
+  DEBUG(semaphore, "Create [%s]\n", name);
+
+  prv = new struct semaphore_private_t();
+
+#ifdef WIN32
+  prv->semaphore = CreateSemaphore(NULL,  // default security attributes
+                                   0, // initial count
+                                   2147483647, // maximum count (Max LONG)
+                                   NULL); // unnamed semaphore
+#else
+  sem_init(&prv->semaphore, 0, 0);
+#endif
+}
+
+Semaphore::~Semaphore()
+{
+  DEBUG(semaphore, "Delete [%s]\n", name);
+
+#ifdef WIN32
+  CloseHandle(prv->semaphore);
+#else
+  sem_destroy(&prv->semaphore);
+#endif
+
+  if(prv) delete prv;
+}
+
+void Semaphore::post()
+{
+  DEBUG(semaphore, "Post [%s]\n", name);
+
+#ifdef WIN32
+  ReleaseSemaphore(prv->semaphore, 1, NULL);
+#else
+  sem_post(&prv->semaphore);
+#endif
+}
+
+void Semaphore::wait()
+{
+  DEBUG(semaphore, "Wait [%s]\n", name);
+
+#ifdef WIN32
+  WaitForSingleObject(prv->semaphore, INFINITE);
+#else
+  sem_wait(&prv->semaphore);
+#endif
+}
+
+#ifdef TEST_SEMAPHORE
+//deps:
+//cflags: -I.. $(PTHREAD_CFLAGS)
+//libs: $(PTHREAD_LIBS)
+#include <test.h>
+
+TEST_BEGIN;
+
+// TODO: Put some testcode here (see test.h for usable macros).
+TEST_TRUE(false, "No tests yet!");
+
+TEST_END;
+
+#endif/*TEST_SEMAPHORE*/
diff --git a/src/semaphore.h b/src/semaphore.h
new file mode 100644
index 0000000..7e39f5a
--- /dev/null
+++ b/src/semaphore.h
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            semaphore.h
+ *
+ *  Sat Oct  8 17:44:13 CEST 2005
+ *  Copyright  2005 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of Pracro.
+ *
+ *  Pracro is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Pracro is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Pracro; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __PRACRO_SEMAPHORE_H__
+#define __PRACRO_SEMAPHORE_H__
+
+struct semaphore_private_t;
+
+class Semaphore {
+public:
+  Semaphore(const char *name = "");
+  ~Semaphore();
+
+  void post();
+  void wait();
+
+private:
+  struct semaphore_private_t *prv;
+  const char *name;
+};
+
+#endif/*__PRACRO_SEMAPHORE_H__*/
diff --git a/src/thread.cc b/src/thread.cc
new file mode 100644
index 0000000..6e216e9
--- /dev/null
+++ b/src/thread.cc
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            thread.cc
+ *
+ *  Tue Jan 24 08:11:37 CET 2012
+ *  Copyright 2012 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "thread.h"
+
+#include <stdio.h>
+#include <hugin.hpp>
+
+Thread::Thread()
+{}
+
+Thread::~Thread()
+{}
+
+void Thread::run()
+{
+  DEBUG(thread, "Thread::run()\n");
+#ifdef WIN32
+  tid = CreateThread(NULL, 0, thread_run, this, 0, NULL);
+#else
+  pthread_create(&tid, NULL, thread_run, this);
+#endif/*WIN32*/
+}
+
+void Thread::wait_stop()
+{
+#ifdef WIN32
+  WaitForSingleObject(tid, INFINITE);
+#else
+  pthread_join(tid, NULL);
+#endif/*WIN32*/
+}
+
+#ifdef WIN32
+DWORD WINAPI
+#else
+void*
+#endif/*WIN32*/
+Thread::thread_run(void *data)
+{
+  DEBUG(thread, "Thread run\n");
+  Thread *t = (Thread*)data;
+  t->thread_main();
+  return 0;
+}
diff --git a/src/thread.h b/src/thread.h
new file mode 100644
index 0000000..f2c1dd0
--- /dev/null
+++ b/src/thread.h
@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/***************************************************************************
+ *            thread.h
+ *
+ *  Tue Jan 24 08:11:37 CET 2012
+ *  Copyright 2012 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#pragma once
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif/*WIN32*/
+
+class Thread {
+public:
+  Thread();
+  virtual ~Thread();
+
+  void run();
+  void wait_stop();
+
+protected:
+  virtual void thread_main() = 0;
+  
+private:
+#ifdef WIN32
+  HANDLE tid;
+  static DWORD WINAPI
+#else
+  pthread_t tid;
+  static void*
+#endif/*WIN32*/
+    thread_run(void *data);
+};
diff --git a/src/versionstr.cc b/src/versionstr.cc
new file mode 100644
index 0000000..90557f6
--- /dev/null
+++ b/src/versionstr.cc
@@ -0,0 +1,151 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ *            versionstr.cc
+ *
+ *  Wed Jul 22 11:41:32 CEST 2009
+ *  Copyright 2009 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#include "versionstr.h"
+
+#include <memory.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+// Workaround - major, minor and patch are defined as macros when using _GNU_SOURCES
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+#ifdef patch
+#undef patch
+#endif
+
+VersionStr::VersionStr(std::string v) throw(const char *)
+{
+  memset(version, 0, sizeof(version));
+  set(v);
+}
+
+VersionStr::VersionStr(size_t major, size_t minor, size_t patch)
+{
+  version[0] = major;
+  version[1] = minor;
+  version[2] = patch;
+}
+
+void VersionStr::set(std::string v) throw(const char *)
+{
+  std::string num;
+  size_t idx = 0;
+  for(size_t i = 0; i < v.length(); i++) {
+    if(v[i] == '.') {
+      if(idx > 2) throw "Version string is too long.";
+      version[idx] = atoi(num.c_str());
+      idx++;
+      num = "";
+    } else if(v[i] >= '0' && v[i] <= '9') {
+      num.append(1, v[i]);
+    } else {
+      throw "Version string contains illegal character.";
+    }
+  }
+  if(idx > 2) throw "Version string is too long.";
+  version[idx] = atoi(num.c_str());
+}
+
+VersionStr::operator std::string() const
+{
+  std::string v;
+  char buf[64];
+  if(patch()) {
+    sprintf(buf, "%d.%d.%d", (int)major(), (int)minor(), (int)patch());
+  } else {
+    sprintf(buf, "%d.%d", (int)major(), (int)minor());
+  }
+  v = buf;
+  return v;
+}
+  
+void VersionStr::operator=(std::string v) throw(const char *)
+{
+  set(v);
+}
+
+// return a - b simplified as -1, 0 or 1
+static int vdiff(const VersionStr &a, const VersionStr &b)
+{
+  if(a.major() < b.major()) return -1;
+  if(a.major() > b.major()) return 1;
+  if(a.minor() < b.minor()) return -1;
+  if(a.minor() > b.minor()) return 1;
+  if(a.patch() < b.patch()) return -1;
+  if(a.patch() > b.patch()) return 1;
+  return 0;
+}
+
+bool VersionStr::operator<(const VersionStr &other) const
+{
+  if(vdiff(*this, other) == -1) return true;
+  return false;
+}
+
+bool VersionStr::operator>(const VersionStr &other) const
+{
+  if(vdiff(*this, other) == 1) return true;
+  return false;
+}
+
+bool VersionStr::operator==(const VersionStr &other) const
+{
+  if(vdiff(*this, other) == 0) return true;
+  return false;
+}
+
+bool VersionStr::operator<=(const VersionStr &other) const
+{
+  if(vdiff(*this, other) != 1) return true;
+  return false;
+}
+
+bool VersionStr::operator>=(const VersionStr &other) const
+{
+  if(vdiff(*this, other) != -1) return true;
+  return false;
+}
+
+size_t VersionStr::major() const
+{
+  return version[0];
+}
+
+size_t VersionStr::minor() const
+{
+  return version[1];
+}
+
+size_t VersionStr::patch() const
+{
+  return version[2];
+}
diff --git a/src/versionstr.h b/src/versionstr.h
new file mode 100644
index 0000000..ecb1df3
--- /dev/null
+++ b/src/versionstr.h
@@ -0,0 +1,112 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set et sw=2 ts=2: */
+/***************************************************************************
+ *            versionstr.h
+ *
+ *  Wed Jul 22 11:41:32 CEST 2009
+ *  Copyright 2009 Bent Bisballe Nyeng
+ *  deva@aasimon.org
+ ****************************************************************************/
+
+/*
+ *  This file is part of DrumGizmo.
+ *
+ *  DrumGizmo is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  DrumGizmo is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with DrumGizmo; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+#ifndef __PRACRO_VERSIONSTR_H__
+#define __PRACRO_VERSIONSTR_H__
+
+#include <string>
+
+// Workaround - major, minor and patch are defined as macros when using _GNU_SOURCES
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+#ifdef patch
+#undef patch
+#endif
+
+/**
+ * VersionStr class.
+ * It hold a version number and is capable of correct sorting, as well as string 
+ * conversion both ways.
+ */
+class VersionStr {
+public:
+  /**
+   * Constructor.
+   * Throws an exeption if the string does not parse.
+   * @param v A std::string containing a version string on the form a.b or a.b.c
+   */
+  VersionStr(std::string v) throw(const char *);
+
+  /**
+   * Constructor.
+   * @param major A size_t containing the major version number.
+   * @param minor A size_t containing the minor version number.
+   * @param patch A size_t containing the patch level.
+   */
+  VersionStr(size_t major = 0, size_t minor = 0, size_t patch = 0);
+
+  /**
+   * Typecast to std::string operator.
+   * It simply converts the version numbers into a string of the form major.minor
+   * (if patch i 0) or major.minor.patch
+   */
+  operator std::string() const;
+
+  /**
+   * Assignment from std::string operator.
+   * Same as in the VersionStr(std::string v) constructor.
+   * Throws an exeption if the string does not parse.
+   */
+  void operator=(std::string v) throw(const char *);
+
+  /**
+   * Comparison operator.
+   * The version objects are sorted according to their major, minor and patch
+   * level numbers.
+   */
+  bool operator<(const VersionStr &other) const;
+  bool operator==(const VersionStr &other) const;
+  bool operator>(const VersionStr &other) const;
+  bool operator>=(const VersionStr &other) const;
+  bool operator<=(const VersionStr &other) const;
+
+
+  /**
+   * @return Major version number.
+   */
+  size_t major() const;
+
+  /**
+   * @return Minor version number.
+   */
+  size_t minor() const;
+
+  /**
+   * @return Patch level.
+   */
+  size_t patch() const;
+
+private:
+  void set(std::string v) throw(const char *);
+  size_t version[3];
+};
+
+#endif/*__PRACRO_VERSIONSTR_H__*/