From 34a194cc101d7c77202b79a06e285573541d823f Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 16 Mar 2019 15:32:52 +0100
Subject: Only start backends with active instances

---
 midimonster.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'midimonster.h')

diff --git a/midimonster.h b/midimonster.h
index 98d8459..a3e5e1f 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -29,7 +29,7 @@ struct _managed_fd;
  * 	* int init()
  * 		The only function that should be exported by the shared object.
  * 		Called when the shared object is attached. Should register
- * 		a backend structure with the core.
+ * 		a backend structure containing callable entry points with the core.
  * 		Returning anything other than zero causes midimonster to fail the
  * 		startup checks.
  * 	* mmbackend_configure
@@ -46,7 +46,8 @@ struct _managed_fd;
  * 		out-of-memory condition and terminates the program.
  * 	* mmbackend_start
  * 		Called after all instances have been created and all mappings
- * 		have been set up. May be used to connect to backing hardware
+ * 		have been set up. Only backends for which instances have been configured
+ * 		receive the start call. May be used to connect to backing hardware
  * 		or to update runtime-specific data in the various data structures.
  * 		Returning a non-zero value signals an error starting the backend
  * 		and stops further progress.
@@ -68,7 +69,9 @@ struct _managed_fd;
  *			Return the maximum sleep interval for this backend in milliseconds.
  *			If not implemented, a maximum interval of one second is used.
  *	* mmbackend_shutdown
- *		Clean up all allocations, finalize all hardware connections.
+ *		Clean up all allocations, finalize all hardware connections. All registered
+ *		backends receive the shutdown call, regardless of whether they have been
+ *		started previously.
  *		Return value is currently ignored.
  */
 typedef int (*mmbackend_handle_event)(struct _backend_instance* inst, size_t channels, struct _backend_channel** c, struct _channel_value* v);
-- 
cgit v1.2.3


From 28000d6e09d5372ada278bc8e8d9960c5f15e678 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Tue, 19 Mar 2019 00:31:47 +0100
Subject: Allow the fd set to be updated at translation time (Fixes #8)

---
 midimonster.c | 40 ++++++++++++++++++++++++++++++----------
 midimonster.h |  2 --
 2 files changed, 30 insertions(+), 12 deletions(-)

(limited to 'midimonster.h')

diff --git a/midimonster.c b/midimonster.c
index 629a0d9..798f06d 100644
--- a/midimonster.c
+++ b/midimonster.c
@@ -20,6 +20,7 @@ static size_t mappings = 0;
 static channel_mapping* map = NULL;
 static size_t fds = 0;
 static managed_fd* fd = NULL;
+static volatile sig_atomic_t fd_set_dirty = 1;
 static uint64_t global_timestamp = 0;
 
 static event_collection event_pool[2] = {
@@ -114,6 +115,7 @@ int mm_manage_fd(int new_fd, char* back, int manage, void* impl){
 				fd[u].fd = -1;
 				fd[u].backend = NULL;
 				fd[u].impl = NULL;
+				fd_set_dirty = 1;
 			}
 			return 0;
 		}
@@ -143,6 +145,7 @@ int mm_manage_fd(int new_fd, char* back, int manage, void* impl){
 	fd[u].fd = new_fd;
 	fd[u].backend = b;
 	fd[u].impl = impl;
+	fd_set_dirty = 1;
 	return 0;
 }
 
@@ -218,6 +221,28 @@ int usage(char* fn){
 	return EXIT_FAILURE;
 }
 
+static fd_set fds_collect(int* max_fd){
+	size_t u = 0;
+	fd_set rv_fds;
+
+	if(max_fd){
+		*max_fd = -1;
+	}
+
+	DBGPF("Building selector set from %zu FDs registered to core\n", fds);
+	FD_ZERO(&rv_fds);
+	for(u = 0; u < fds; u++){
+		if(fd[u].fd >= 0){
+			FD_SET(fd[u].fd, &rv_fds);
+			if(max_fd){
+				*max_fd = max(*max_fd, fd[u].fd);
+			}
+		}
+	}
+
+	return rv_fds;
+}
+
 int main(int argc, char** argv){
 	fd_set all_fds, read_fds;
 	event_collection* secondary = NULL;
@@ -262,18 +287,13 @@ int main(int argc, char** argv){
 		goto bail;
 	}
 
-	//create initial fd set
-	DBGPF("Building selector set from %zu FDs registered to core\n", fds);
-	FD_ZERO(&all_fds);
-	for(u = 0; u < fds; u++){
-		if(fd[u].fd >= 0){
-			FD_SET(fd[u].fd, &all_fds);
-			maxfd = max(maxfd, fd[u].fd);
-		}
-	}
-
 	//process events
 	while(!shutdown_requested){
+		//build fd set if necessary
+		if(fd_set_dirty){
+			all_fds = fds_collect(&maxfd);
+			fd_set_dirty = 0;
+		}
 		//wait for & translate events
 		read_fds = all_fds;
 		tv = backend_timeout();
diff --git a/midimonster.h b/midimonster.h
index a3e5e1f..cffbf67 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -179,8 +179,6 @@ channel* mm_channel(instance* i, uint64_t ident, uint8_t create);
 /*
  * Register a file descriptor to be selected on. The backend
  * will be notified via the mmbackend_process_fd call.
- * This function may only be called from within the mmbackend_start
- * procedure.
  */
 int mm_manage_fd(int fd, char* backend, int manage, void* impl);
 /*
-- 
cgit v1.2.3


From 0928bc2c59a38c411a35c49d83fd468e5e0dc43c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Tue, 19 Mar 2019 00:36:23 +0100
Subject: Documentation update

---
 midimonster.h | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'midimonster.h')

diff --git a/midimonster.h b/midimonster.h
index cffbf67..572b5fb 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -177,12 +177,13 @@ instance* mm_instance_find(char* backend, uint64_t ident);
 channel* mm_channel(instance* i, uint64_t ident, uint8_t create);
 //TODO channel* mm_channel_find()
 /*
- * Register a file descriptor to be selected on. The backend
- * will be notified via the mmbackend_process_fd call.
+ * Register (manage = 1) or unregister (manage = 0) a file descriptor
+ * to be selected on. The backend will be notified when the descriptor
+ * becomes ready to read via its registered mmbackend_process_fd call.
  */
 int mm_manage_fd(int fd, char* backend, int manage, void* impl);
 /*
- * Notifies the core of a channel event. Used by backends to
+ * Notifies the core of a channel event. Called by backends to
  * inject events gathered from their backing implementation.
  */
 int mm_channel_event(channel* c, channel_value v);
-- 
cgit v1.2.3


From b618c4a6b74a52f830ca53029e1cc680d56a2501 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 6 Jul 2019 17:25:12 +0200
Subject: Implement Lua backend

---
 .travis.yml       |   1 +
 README.md         |  13 ++--
 backends/Makefile |   4 +-
 backends/lua.c    | 202 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 backends/lua.h    |  21 ++++++
 backends/lua.md   |  49 +++++++++++++
 configs/demo.lua  |  21 ++++++
 configs/lua.cfg   |  35 ++++++++++
 midimonster.h     |   1 +
 9 files changed, 342 insertions(+), 5 deletions(-)
 create mode 100644 backends/lua.c
 create mode 100644 backends/lua.h
 create mode 100644 backends/lua.md
 create mode 100644 configs/demo.lua
 create mode 100644 configs/lua.cfg

(limited to 'midimonster.h')

diff --git a/.travis.yml b/.travis.yml
index ab047ce..66bfd9a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -20,6 +20,7 @@ addons:
      - libasound2-dev
      - libevdev-dev
      - libola-dev
+     - liblua5.3-dev
     packages: &core_build_gpp_latest
      - *core_build
      - gcc-8
diff --git a/README.md b/README.md
index 6265581..ee907a6 100644
--- a/README.md
+++ b/README.md
@@ -12,12 +12,15 @@ Currently, the MIDIMonster supports the following protocols:
 * evdev input devices (Linux)
 * Open Lighting Architecture (OLA)
 
+with additional flexibility provided by a Lua scripting environment.
+
 The MIDIMonster allows the user to translate any channel on one protocol into channel(s)
 on any other (or the same) supported protocol, for example to:
 
 * Translate MIDI Control Changes into Notes ([Example configuration](configs/unifest-17.cfg))
 * Translate MIDI Notes into ArtNet or sACN ([Example configuration](configs/launchctl-sacn.cfg))
 * Translate OSC messages into MIDI ([Example configuration](configs/midi-osc.cfg))
+* Dynamically route and modify events using the Lua programming language ([Example configuration](configs/lua.cfg) and [Script](configs/demo.lua)) to create your own lighting controller
 * Use an OSC app as a simple lighting controller via ArtNet or sACN
 * Visualize ArtNet data using OSC tools
 * Control lighting fixtures or DAWs using gamepad controllers ([Example configuration](configs/evdev.conf))
@@ -88,6 +91,7 @@ special information. These documentation files are located in the `backends/` di
 * [`loopback` backend documentation](backends/loopback.md)
 * [`ola` backend documentation](backends/ola.md)
 * [`osc` backend documentation](backends/osc.md)
+* [`lua` backend documentation](backends/lua.md)
 
 ## Building
 
@@ -99,10 +103,11 @@ This section will explain how to build the provided sources to be able to run
 In order to build the MIDIMonster, you'll need some libraries that provide
 support for the protocols to translate.
 
-* libasound2-dev (for the MIDI backend)
-* libevdev-dev (for the evdev backend)
-* libola-dev (for the optional OLA backend)
-* pkg-config (as some projects and systems like to spread their files around)
+* `libasound2-dev` (for the MIDI backend)
+* `libevdev-dev` (for the evdev backend)
+* `liblua5.3-dev` (for the lua backend)
+* `libola-dev` (for the optional OLA backend)
+* `pkg-config` (as some projects and systems like to spread their files around)
 * A C compiler
 * GNUmake
 
diff --git a/backends/Makefile b/backends/Makefile
index c11de56..fe88669 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -1,7 +1,7 @@
 .PHONY: all clean full
 OPTIONAL_BACKENDS = ola.so
 LINUX_BACKENDS = midi.so evdev.so
-BACKENDS = artnet.so osc.so loopback.so sacn.so
+BACKENDS = artnet.so osc.so loopback.so sacn.so lua.so
 BACKEND_LIB = libmmbackend.o
 
 SYSTEM := $(shell uname -s)
@@ -27,6 +27,8 @@ evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev)
 evdev.so: LDLIBS = $(shell pkg-config --libs libevdev)
 ola.so: LDLIBS = -lola
 ola.so: CPPFLAGS += -Wno-write-strings
+lua.so: CFLAGS += $(shell pkg-config --cflags lua5.3)
+lua.so: LDLIBS += $(shell pkg-config --libs lua5.3)
 
 %.so :: %.c %.h $(BACKEND_LIB)
 	$(CC) $(CFLAGS) $(LDLIBS) $< $(ADDITIONAL_OBJS) -o $@ $(LDFLAGS)
diff --git a/backends/lua.c b/backends/lua.c
new file mode 100644
index 0000000..ae2d460
--- /dev/null
+++ b/backends/lua.c
@@ -0,0 +1,202 @@
+#include <string.h>
+#include "lua.h"
+
+#define BACKEND_NAME "lua"
+#define LUA_REGISTRY_KEY "_midimonster_lua_instance"
+
+//TODO instance identification for callvacks
+
+int init(){
+	backend lua = {
+		.name = BACKEND_NAME,
+		.conf = lua_configure,
+		.create = lua_instance,
+		.conf_instance = lua_configure_instance,
+		.channel = lua_channel,
+		.handle = lua_set,
+		.process = lua_handle,
+		.start = lua_start,
+		.shutdown = lua_shutdown
+	};
+
+	//register backend
+	if(mm_backend_register(lua)){
+		fprintf(stderr, "Failed to register lua backend\n");
+		return 1;
+	}
+	return 0;
+}
+
+static int lua_callback_output(lua_State* interpreter){
+	int arguments = lua_gettop(interpreter);
+	size_t n;
+	channel_value val;
+	const char* channel_name = NULL;
+	channel* channel = NULL;
+	instance* inst = NULL;
+	lua_instance_data* data = NULL;
+
+	if(arguments != 2){
+		fprintf(stderr, "Lua output function called with %d arguments, expected 2\n", arguments);
+		return 0;
+	}
+
+	channel_name = lua_tostring(interpreter, 1);
+	val.normalised = clamp(lua_tonumber(interpreter, 2), 1.0, 0.0);
+
+	lua_pushstring(interpreter, LUA_REGISTRY_KEY);
+	lua_gettable(interpreter, LUA_REGISTRYINDEX);
+	inst = (instance *) lua_touserdata(interpreter, -1);
+	data = (lua_instance_data*) inst->impl;
+
+	for(n = 0; n < data->channels; n++){
+		if(!strcmp(channel_name, data->channel_name[n])){
+			channel = mm_channel(inst, n, 0);
+			if(!channel){
+				return 0;
+			}
+			mm_channel_event(channel, val);
+			return 0;
+		}
+	}
+
+	fprintf(stderr, "Tried to set unknown channel %s.%s\n", inst->name, channel_name);
+	return 0;
+}
+
+static int lua_configure(char* option, char* value){
+	fprintf(stderr, "The lua backend does not take any global configuration\n");
+	return 1;
+}
+
+static int lua_configure_instance(instance* inst, char* option, char* value){
+	lua_instance_data* data = (lua_instance_data*) inst->impl;
+
+	if(!strcmp(option, "script")){
+		if(luaL_dofile(data->interpreter, value)){
+			fprintf(stderr, "Failed to load lua source file %s for instance %s: %s\n", value, inst->name, lua_tostring(data->interpreter, -1));
+			return 1;
+		}
+		return 0;
+	}
+
+	fprintf(stderr, "Unknown configuration parameter %s for lua backend\n", option);
+	return 1;
+}
+
+static instance* lua_instance(){
+	instance* inst = mm_instance();
+	if(!inst){
+		return NULL;
+	}
+
+	lua_instance_data* data = calloc(1, sizeof(lua_instance_data));
+	if(!data){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return NULL;
+	}
+
+	//load the interpreter
+	data->interpreter = luaL_newstate();
+	if(!data->interpreter){
+		fprintf(stderr, "Failed to initialize LUA\n");
+		free(data);
+		return NULL;
+	}
+	luaL_openlibs(data->interpreter);
+
+	//register lua api functions
+	lua_register(data->interpreter, "output", lua_callback_output);
+
+	//store instance pointer to the lua state
+	lua_pushstring(data->interpreter, LUA_REGISTRY_KEY);
+	lua_pushlightuserdata(data->interpreter, (void *) inst);
+	lua_settable(data->interpreter, LUA_REGISTRYINDEX);   
+
+	inst->impl = data;
+	return inst;
+}
+
+static channel* lua_channel(instance* inst, char* spec){
+	size_t u;
+	lua_instance_data* data = (lua_instance_data*) inst->impl;
+
+	//find matching channel
+	for(u = 0; u < data->channels; u++){
+		if(!strcmp(spec, data->channel_name[u])){
+			break;
+		}
+	}
+
+	//allocate new channel
+	if(u == data->channels){
+		data->channel_name = realloc(data->channel_name, (u + 1) * sizeof(char*));
+		if(!data->channel_name){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return NULL;
+		}
+
+		data->channel_name[u] = strdup(spec);
+		if(!data->channel_name[u]){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return NULL;
+		}
+		data->channels++;
+	}
+
+	return mm_channel(inst, u, 1);
+}
+
+static int lua_set(instance* inst, size_t num, channel** c, channel_value* v){
+	size_t n = 0;
+	lua_instance_data* data = (lua_instance_data*) inst->impl;
+
+	for(n = 0; n < num; n++){
+		//call lua channel handlers
+		lua_getglobal(data->interpreter, data->channel_name[c[n]->ident]);
+		lua_pushnumber(data->interpreter, v[n].normalised);
+		if(lua_pcall(data->interpreter, 1, 0, 0) != LUA_OK){
+			fprintf(stderr, "Failed to call handler for %s.%s: %s\n", inst->name, data->channel_name[c[n]->ident], lua_tostring(data->interpreter, -1));
+			lua_pop(data->interpreter, 1);
+		}
+	}
+	return 0;
+}
+
+static int lua_handle(size_t num, managed_fd* fds){
+	//TODO call timer callbacks
+	return 0;
+}
+
+static int lua_start(){
+	//TODO start timers / register fds
+	return 0;
+}
+
+static int lua_shutdown(){
+	size_t n, u, p;
+	instance** inst = NULL;
+	lua_instance_data* data = NULL;
+
+	if(mm_backend_instances(BACKEND_NAME, &n, &inst)){
+		fprintf(stderr, "Failed to fetch instance list\n");
+		return 1;
+	}
+
+	for(u = 0; u < n; u++){
+		data = (lua_instance_data*) inst[u]->impl;
+		//stop the interpreter
+		lua_close(data->interpreter);
+		//cleanup channel data
+		for(p = 0; p < data->channels; p++){
+			free(data->channel_name[p]);
+		}
+		free(data->channel_name);
+		free(inst[u]->impl);
+	}
+
+	free(inst);
+
+	fprintf(stderr, "Lua backend shut down\n");
+	return 0;
+}
diff --git a/backends/lua.h b/backends/lua.h
new file mode 100644
index 0000000..27e1afd
--- /dev/null
+++ b/backends/lua.h
@@ -0,0 +1,21 @@
+#include "midimonster.h"
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+int init();
+static int lua_configure(char* option, char* value);
+static int lua_configure_instance(instance* inst, char* option, char* value);
+static instance* lua_instance();
+static channel* lua_channel(instance* inst, char* spec);
+static int lua_set(instance* inst, size_t num, channel** c, channel_value* v);
+static int lua_handle(size_t num, managed_fd* fds);
+static int lua_start();
+static int lua_shutdown();
+
+typedef struct /*_lua_instance_data*/ {
+	size_t channels;
+	char** channel_name;
+	lua_State* interpreter;
+} lua_instance_data;
diff --git a/backends/lua.md b/backends/lua.md
new file mode 100644
index 0000000..91e8fe2
--- /dev/null
+++ b/backends/lua.md
@@ -0,0 +1,49 @@
+### The `lua` backend
+
+The `lua` backend provides a flexible programming environment, allowing users to route and manipulate
+events using the Lua programming language.
+
+Every instance has it's own interpreter state which can be loaded with custom handler scripts.
+
+To process incoming channel events, the MIDIMonster calls corresponding Lua functions with
+the value (as a Lua `number` type) as parameter. To send output on a channel, the Lua environment
+provides the function `output(channel-name, value)`.
+
+Example script:
+```
+function bar(value)
+	output("foo", value / 2)
+end
+```
+
+Input values range between 0.0 and 1.0, output values are clamped to the same range.
+
+#### Global configuration
+
+The backend does not take any global configuration.
+
+#### Instance configuration
+
+| Option	| Example value		| Default value 	| Description		|
+|---------------|-----------------------|-----------------------|-----------------------|
+| `source`	| `script.lua`		| none			| Lua source file	|
+
+A single instance may have multiple `source` options specified, which will all be read cumulatively.
+
+#### Channel specification
+
+Channel names may be any valid Lua function name.
+
+Example mapping:
+```
+lua1.foo > lua2.bar
+```
+
+#### Known bugs / problems
+
+Using `output` as an input channel name to a Lua instance does not work, as the interpreter has
+`output` globally assigned to the event output function. Using `output` as an output channel name
+via `output("output", value)` works as intended.
+
+The path to the Lua source files is relative to the current working directory. This may lead
+to problems when copying configuration between installations.
diff --git a/configs/demo.lua b/configs/demo.lua
new file mode 100644
index 0000000..e816ac4
--- /dev/null
+++ b/configs/demo.lua
@@ -0,0 +1,21 @@
+-- This example MIDIMonstaer Lua script spreads one input channel onto multiple output
+-- channels using a polynomial function evaluated at multiple points. This effect can
+-- be visualized e.g. with martrix (https://github.com/cbdevnet/martrix).
+
+-- This is just a demonstration of global variables
+foo = 0
+
+-- The polynomial to evaluate
+function polynomial(offset, x)
+	return math.exp(-20 * (x - offset) ^ 2)
+end
+
+-- Handler function for the input channel
+function input(value)
+	foo = foo + 1
+	print("input at ", value, foo)
+
+	for chan=0,10 do
+		output("out" .. chan, polynomial(value, (1 / 10) * chan))
+	end
+end
diff --git a/configs/lua.cfg b/configs/lua.cfg
new file mode 100644
index 0000000..9182122
--- /dev/null
+++ b/configs/lua.cfg
@@ -0,0 +1,35 @@
+; This configuration uses a Lua script to distribute one input channel (from either a mouse
+; button or an axis control) onto multiple output channels (on ArtNet).
+
+[backend artnet]
+bind = 0.0.0.0
+
+[evdev mouse]
+device = /dev/input/by-path/platform-i8042-serio-2-event-mouse
+
+[evdev xbox]
+input = Xbox Wireless
+axis.ABS_X = 34300 0 65535 255 4095
+
+[lua lua]
+script = configs/demo.lua
+
+[artnet art]
+universe = 0
+destination = 255.255.255.255
+
+[map]
+mouse.EV_KEY.BTN_LEFT > lua.input
+xbox.EV_ABS.ABS_X > lua.input
+
+art.1 < lua.out0
+art.2 < lua.out1
+art.3 < lua.out2
+art.4 < lua.out3
+art.5 < lua.out4
+art.6 < lua.out5
+art.7 < lua.out6
+art.8 < lua.out7
+art.9 < lua.out8
+art.10 < lua.out9
+art.11 < lua.out10
diff --git a/midimonster.h b/midimonster.h
index 572b5fb..8a18155 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -5,6 +5,7 @@
 #include <stdint.h>
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #define min(a,b) (((a) < (b)) ? (a) : (b))
+#define clamp(val,max,min) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
 #ifdef DEBUG
 	#define DBGPF(format, ...) fprintf(stderr, (format), __VA_ARGS__)
 	#define DBG(message) fprintf(stderr, "%s", (message))
-- 
cgit v1.2.3


From 5bd8e81e2821f1378c6773fbc1f06df063dbbd22 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 20 Jul 2019 18:10:56 +0200
Subject: Implement multi-channel mapping syntax

---
 README.md                  |  30 ++++++-
 TODO                       |   2 +-
 config.c                   | 196 +++++++++++++++++++++++++++++++++++++++++----
 configs/launchctl-sacn.cfg |  25 ++----
 midimonster.h              |  53 +++++++++++-
 monster.cfg                |  46 ++---------
 6 files changed, 274 insertions(+), 78 deletions(-)

(limited to 'midimonster.h')

diff --git a/README.md b/README.md
index ee907a6..bce7b71 100644
--- a/README.md
+++ b/README.md
@@ -56,10 +56,24 @@ lines of the form `option = value`.
 Lines starting with a semicolon are treated as comments and ignored. Inline comments
 are not currently supported.
 
+Example configuration files may be found in [configs/](configs/).
+
+### Backend and instance configuration
+
 A configuration section may either be a *backend configuration* section, started by
 `[backend <backend-name>]`, an *instance configuration* section, started by
 `[<backend-name> <instance-name>]` or a *mapping* section started by `[map]`.
 
+Backends document their global options in their [backend documentation](#backend-documentation).
+Some backends may not require global configuration, in which case the configuration
+section for that particular backend can be omitted.
+
+To make an instance available for mapping channels, it requires at least the
+`[<backend-name> <instance-name>]` configuration stanza. Most backends require
+additional configuration for their instances.
+
+### Channel mapping
+
 The `[map]` section consists of lines of channel-to-channel assignments, reading like
 
 ```
@@ -76,7 +90,21 @@ output eachothers events.
 
 The last line is a shorter way to create a bi-directional mapping.
 
-Example configuration files may be found in [configs/](configs/).
+### Multi-channel mapping
+
+To make mapping large contiguous sets of channels easier, channel names may contain
+expressions of the form `{<start>..<end>}`, with *start* and *end* being positive integers
+delimiting a range of channels.  Multiple such expressions may be used in one channel
+specification, with the rightmost expression being incremented (or decremented) first for
+evaluation.
+
+Both sides of a multi-channel assignment need to have the same number of channels.
+
+Example multi-channel mapping:
+
+```
+instance-a.channel{1..10} > instance-b.{10..1}
+```
 
 ## Backend documentation
 
diff --git a/TODO b/TODO
index f39dae0..76f2c4e 100644
--- a/TODO
+++ b/TODO
@@ -4,5 +4,5 @@ Optimize core channel search (store backend offset)
 Printing backend
 
 document example configs
-lua timer
 evdev relative axis size
+mm_managed_fd.impl is not freed currently
diff --git a/config.c b/config.c
index b81aeaf..24f1223 100644
--- a/config.c
+++ b/config.c
@@ -21,25 +21,164 @@ static backend* current_backend = NULL;
 static instance* current_instance = NULL;
 
 static char* config_trim_line(char* in){
-	ssize_t u;
+	ssize_t n;
 	//trim front
 	for(; *in && !isgraph(*in); in++){
 	}
 
 	//trim back
-	for(u = strlen(in); u >= 0 && !isgraph(in[u]); u--){
-		in[u] = 0;
+	for(n = strlen(in); n >= 0 && !isgraph(in[n]); n--){
+		in[n] = 0;
 	}
 
 	return in;
 }
 
+static int config_glob_parse(channel_glob* glob, char* spec, size_t length){
+	char* parse_offset = NULL;
+	//FIXME might want to allow negative delimiters at some point
+
+	//first interval member
+	glob->limits.u64[0] = strtoul(spec, &parse_offset, 10);
+	if(!parse_offset || parse_offset - spec >= length || strncmp(parse_offset, "..", 2)){
+		return 1;
+	}
+
+	parse_offset += 2;
+	//second interval member
+	glob->limits.u64[1] = strtoul(parse_offset, &parse_offset, 10);
+	if(!parse_offset || parse_offset - spec != length || *parse_offset != '}'){
+		return 1;
+	}
+
+	//calculate number of channels within interval
+	if(glob->limits.u64[0] < glob->limits.u64[1]){
+		glob->values = glob->limits.u64[1] - glob->limits.u64[0] + 1;
+	}
+	else if(glob->limits.u64[0] > glob->limits.u64[1]){
+		glob->values = glob->limits.u64[0] - glob->limits.u64[1] + 1;
+	}
+	else{
+		glob->values = 1;
+	}
+
+	return 0;
+}
+
+static int config_glob_scan(instance* inst, channel_spec* spec){
+	char* glob_start = spec->spec, *glob_end = NULL;
+	size_t u;
+
+	//assume a spec is one channel as default
+	spec->channels = 1;
+
+	//scan and mark globs
+	for(glob_start = strchr(glob_start, '{'); glob_start; glob_start = strchr(glob_start, '{')){
+		glob_end = strchr(glob_start, '}');
+		if(!glob_end){
+			fprintf(stderr, "Failed to parse channel spec, unterminated glob: %s\n", spec->spec);
+			return 1;
+		}
+
+		spec->glob = realloc(spec->glob, (spec->globs + 1) * sizeof(channel_glob));
+		if(!spec->glob){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return 1;
+		}
+
+		spec->glob[spec->globs].offset[0] = glob_start - spec->spec;
+		spec->glob[spec->globs].offset[1] = glob_end - spec->spec;
+		spec->globs++;
+
+		//skip this opening brace
+		glob_start++;
+	}
+
+	//try to parse globs internally
+	spec->internal = 1;
+	for(u = 0; u < spec->globs; u++){
+		if(config_glob_parse(spec->glob + u,
+					spec->spec + spec->glob[u].offset[0] + 1,
+					spec->glob[u].offset[1] - spec->glob[u].offset[0] - 1)){
+			spec->internal = 0;
+			break;
+		}
+	}
+	if(!spec->internal){
+		//TODO try to parse globs externally
+		fprintf(stderr, "Failed to parse glob %lu in %s internally\n", u + 1, spec->spec);
+		return 1;
+	}
+
+	//calculate channel total
+	for(u = 0; u < spec->globs; u++){
+		spec->channels *= spec->glob[u].values;
+	}
+	return 0;
+}
+
+static channel* config_glob_resolve(instance* inst, channel_spec* spec, uint64_t n){
+	size_t glob = 0, glob_length;
+	ssize_t bytes = 0;
+	uint64_t current_value = 0;
+	channel* result = NULL;
+	char* resolved_spec = strdup(spec->spec);
+
+	if(!resolved_spec){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return NULL;
+	}
+
+	//TODO if not internal, try to resolve externally
+
+	//iterate and resolve globs
+	for(glob = spec->globs; glob > 0; glob--){
+		current_value = spec->glob[glob - 1].limits.u64[0] + (n % spec->glob[glob - 1].values);
+		if(spec->glob[glob - 1].limits.u64[0] > spec->glob[glob - 1].limits.u64[1]){
+			current_value = spec->glob[glob - 1].limits.u64[0] - (n % spec->glob[glob - 1].values);
+		}
+		glob_length = spec->glob[glob - 1].offset[1] - spec->glob[glob - 1].offset[0];
+		n /= spec->glob[glob - 1].values;
+
+		//write out value
+		bytes = snprintf(resolved_spec + spec->glob[glob - 1].offset[0],
+				glob_length,
+				"%lu",
+				current_value);
+		if(bytes > glob_length){
+			fprintf(stderr, "Internal error resolving glob %s\n", spec->spec);
+			goto bail;
+		}
+
+		//move trailing data
+		if(bytes < glob_length){
+			memmove(resolved_spec + spec->glob[glob - 1].offset[0] + bytes,
+					resolved_spec + spec->glob[glob - 1].offset[1] + 1,
+					strlen(spec->spec) - spec->glob[glob - 1].offset[1]);
+		}
+	}
+
+	result = inst->backend->channel(inst, resolved_spec);
+	if(spec->globs && !result){
+		fprintf(stderr, "Failed to match multichannel evaluation %s to a channel\n", resolved_spec);
+	}
+
+bail:
+	free(resolved_spec);
+	return result;
+}
+
 static int config_map(char* to_raw, char* from_raw){
 	//create a copy because the original pointer may be used multiple times
 	char* to = strdup(to_raw), *from = strdup(from_raw);
-	char* chanspec_to = to, *chanspec_from = from;
+	channel_spec spec_to = {
+		.spec = to
+	}, spec_from = {
+		.spec = from
+	};
 	instance* instance_to = NULL, *instance_from = NULL;
 	channel* channel_from = NULL, *channel_to = NULL;
+	uint64_t n = 0;
 	int rv = 1;
 
 	if(!from || !to){
@@ -50,21 +189,21 @@ static int config_map(char* to_raw, char* from_raw){
 	}
 
 	//separate channel spec from instance
-	for(; *chanspec_to && *chanspec_to != '.'; chanspec_to++){
+	for(; *(spec_to.spec) && *(spec_to.spec) != '.'; spec_to.spec++){
 	}
 
-	for(; *chanspec_from && *chanspec_from != '.'; chanspec_from++){
+	for(; *(spec_from.spec) && *(spec_from.spec) != '.'; spec_from.spec++){
 	}
 
-	if(!*chanspec_to || !*chanspec_from){
+	if(!spec_from.spec[0] || !spec_to.spec[0]){
 		fprintf(stderr, "Mapping does not contain a proper instance specification\n");
 		goto done;
 	}
 
 	//terminate
-	*chanspec_to = *chanspec_from = 0;
-	chanspec_to++;
-	chanspec_from++;
+	spec_from.spec[0] = spec_to.spec[0] = 0;
+	spec_from.spec++;
+	spec_to.spec++;
 
 	//find matching instances
 	instance_to = instance_match(to);
@@ -75,16 +214,41 @@ static int config_map(char* to_raw, char* from_raw){
 		goto done;
 	}
 
-	channel_from = instance_from->backend->channel(instance_from, chanspec_from);
-	channel_to = instance_to->backend->channel(instance_to, chanspec_to);
-
-	if(!channel_from || !channel_to){
-		fprintf(stderr, "Failed to parse channel specifications\n");
+	//scan for globs
+	if(config_glob_scan(instance_to, &spec_to)
+			|| config_glob_scan(instance_from, &spec_from)){
 		goto done;
 	}
+	
+	if(spec_to.channels != spec_from.channels
+			|| spec_to.channels == 0
+			|| spec_from.channels == 0){
+		fprintf(stderr, "Multi-channel specification size mismatch: %s.%s (%lu channels) - %s.%s (%lu channels)\n",
+				instance_from->name,
+				spec_from.spec,
+				spec_from.channels,
+				instance_to->name,
+				spec_to.spec,
+				spec_to.channels);
+		goto done;
+	}
+
+	//iterate, resolve globs and map
+	rv = 0;
+	for(n = 0; !rv && n < spec_from.channels; n++){
+		channel_from = config_glob_resolve(instance_from, &spec_from, n);
+		channel_to = config_glob_resolve(instance_to, &spec_to, n);
+		
+		if(!channel_from || !channel_to){
+			rv = 1;
+			goto done;
+		}
+		rv |= mm_map_channel(channel_from, channel_to);
+	}
 
-	rv = mm_map_channel(channel_from, channel_to);
 done:
+	free(spec_from.glob);
+	free(spec_to.glob);
 	free(from);
 	free(to);
 	return rv;
diff --git a/configs/launchctl-sacn.cfg b/configs/launchctl-sacn.cfg
index c2dec84..02cd152 100644
--- a/configs/launchctl-sacn.cfg
+++ b/configs/launchctl-sacn.cfg
@@ -6,34 +6,19 @@
 [backend midi]
 name = MIDIMonster
 
-[backend sacn]
+[backend artnet]
 bind = 0.0.0.0
 
 [midi lc]
 read = Launch Control
 
-[sacn out]
-universe = 1
-priority = 100
+[artnet out]
+universe = 0
+destination = 255.255.255.255 
 
 [map]
 
-lc.ch0.cc0 > out.1
-lc.ch0.cc1 > out.2
-lc.ch0.cc2 > out.3
-lc.ch0.cc3 > out.4
-lc.ch0.cc4 > out.5
-lc.ch0.cc5 > out.6
-lc.ch0.cc6 > out.7
-lc.ch0.cc7 > out.8
-lc.ch0.cc8 > out.9
-lc.ch0.cc9 > out.10
-lc.ch0.cc10 > out.11
-lc.ch0.cc11 > out.12
-lc.ch0.cc12 > out.13
-lc.ch0.cc13 > out.14
-lc.ch0.cc14 > out.15
-lc.ch0.cc15 > out.16
+lc.ch0.cc{0..15} > out.{1..16}
 
 lc.ch0.note0 > out.1
 lc.ch0.note1 > out.2
diff --git a/midimonster.h b/midimonster.h
index 8a18155..1fc85b7 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -3,9 +3,15 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
+
+/* Straight-forward min / max macros */
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #define min(a,b) (((a) < (b)) ? (a) : (b))
+
+/* Clamp a value to a range */
 #define clamp(val,max,min) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+/* Debug messages only compile in when DEBUG is set */
 #ifdef DEBUG
 	#define DBGPF(format, ...) fprintf(stderr, (format), __VA_ARGS__)
 	#define DBG(message) fprintf(stderr, "%s", (message))
@@ -14,10 +20,13 @@
 	#define DBG(message)
 #endif
 
+/* Pull in additional defines for non-linux platforms */
 #include "portability.h"
 
+/* Default configuration file name to read when no other is specified */
 #define DEFAULT_CFG "monster.cfg"
 
+/* Forward declare some of the structs so we can use them in eachother */
 struct _channel_value;
 struct _backend_channel;
 struct _backend_instance;
@@ -86,6 +95,7 @@ typedef int (*mmbackend_start)();
 typedef uint32_t (*mmbackend_interval)();
 typedef int (*mmbackend_shutdown)();
 
+/* Channel event value, .normalised is used by backends to determine channel values */
 typedef struct _channel_value {
 	union {
 		double dbl;
@@ -94,6 +104,10 @@ typedef struct _channel_value {
 	double normalised;
 } channel_value;
 
+/* 
+ * Backend callback structure
+ * Used to register a backend with the core using mm_backend_register()
+ */
 typedef struct /*_mm_backend*/ {
 	char* name;
 	mmbackend_configure conf;
@@ -108,6 +122,10 @@ typedef struct /*_mm_backend*/ {
 	mmbackend_interval interval;
 } backend;
 
+/* 
+ * Backend instance structure - do not allocate directly!
+ * Use the memory returned by mm_instance()
+ */
 typedef struct _backend_instance {
 	backend* backend;
 	uint64_t ident;
@@ -115,20 +133,51 @@ typedef struct _backend_instance {
 	char* name;
 } instance;
 
+/*
+ * Channel specification glob
+ */
+typedef struct /*_mm_channel_glob*/ {
+	size_t offset[2];
+	union {
+		void* impl;
+		uint64_t u64[2];
+	} limits;
+	uint64_t values;
+} channel_glob;
+
+/*
+ * (Multi-)Channel specification
+ */
+typedef struct /*_mm_channel_spec*/ {
+	char* spec;
+	uint8_t internal;
+	size_t channels;
+	size_t globs;
+	channel_glob* glob;
+} channel_spec;
+
+/* 
+ * Instance channel structure
+ * Backends may either manage their own channel registry
+ * or use the memory returned by mm_channel()
+ */
 typedef struct _backend_channel {
 	instance* instance;
 	uint64_t ident;
 	void* impl;
 } channel;
 
-//FIXME might be replaced by struct pollfd
-//FIXME who frees impl
+/*
+ * File descriptor management structure
+ * Register for the core event loop using mm_manage_fd()
+ */
 typedef struct _managed_fd {
 	int fd;
 	backend* backend;
 	void* impl;
 } managed_fd;
 
+/* Internal channel mapping structure - Core use only */
 typedef struct /*_mm_channel_mapping*/ {
 	channel* from;
 	size_t destinations;
diff --git a/monster.cfg b/monster.cfg
index 0760571..7db3ec3 100644
--- a/monster.cfg
+++ b/monster.cfg
@@ -1,46 +1,16 @@
-[backend sacn]
-name = sACN source
-bind = 0.0.0.0
-
 [backend artnet]
 bind = 0.0.0.0
 
-[backend ola]
-
 [artnet art]
-universe = 1
-dest = 129.13.215.0
-
-[backend midi]
-name = Monster
-
-;[evdev in]
-;input = Xbox Wireless Controller
-
-[sacn sacn]
-universe = 1
-priority = 100
+universe = 0
+dest = 255.255.255.255
 
-[midi midi]
-read = Axiom
+[evdev mouse]
+input = TPPS
 
-;[ola ola]
+[loopback loop]
 
 [map]
-;in.EV_ABS.ABS_X > sacn.1+2
-;in.EV_ABS.ABS_Y > sacn.3
-;in.EV_ABS.ABS_X > art.1+2
-;in.EV_ABS.ABS_Y > art.3
-;in.EV_ABS.ABS_X > ola.1+2
-;in.EV_ABS.ABS_Y > ola.3
-;in.EV_KEY.BTN_THUMBL > sacn.4
-;in.EV_KEY.BTN_THUMBR > sacn.5
-;in.EV_ABS.ABS_GAS > sacn.6+7
-;in.EV_ABS.ABS_BRAKE > sacn.8
-;ola.1 > midi.cc0.1
-;ola.2+3 > midi.cc0.2
-midi.ch0.pitch > midi.ch0.cc1
-midi.ch0.aftertouch > midi.ch0.cc2
-midi.ch0.cc71 > midi.ch0.pitch
-midi.ch0.cc74 > midi.ch0.aftertouch
-midi.ch0.cc91 > midi.ch0.pressure1
+art.{3..4}{4..3} > loop.chan{4..3}{3..4}
+art.{1..10} > loop.data{1..10}
+art.{500..599} > loop.test{500..599}
-- 
cgit v1.2.3


From 59857ead2d439d450afc6f5144c9c08e8d0c8a5c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Wed, 24 Jul 2019 21:12:01 +0200
Subject: Fix issues found by Coverity Scan

---
 backends/lua.c | 10 +++++-----
 midimonster.h  |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'midimonster.h')

diff --git a/backends/lua.c b/backends/lua.c
index 8e221d1..4d946cd 100644
--- a/backends/lua.c
+++ b/backends/lua.c
@@ -61,7 +61,7 @@ static uint32_t lua_interval(){
 }
 
 static int lua_update_timerfd(){
-	uint64_t interval, gcd, residual;
+	uint64_t interval = 0, gcd, residual;
 	size_t n = 0;
 	#ifdef MMBACKEND_LUA_TIMERFD
 	struct itimerspec timer_config = {
@@ -396,11 +396,11 @@ static int lua_handle(size_t num, managed_fd* fds){
 		return 1;
 	}
 	#else
-		if(!last_timestamp){
-			last_timestamp = mm_timestamp();
-		}
-		delta = mm_timestamp() - last_timestamp;
+	if(!last_timestamp){
 		last_timestamp = mm_timestamp();
+	}
+	delta = mm_timestamp() - last_timestamp;
+	last_timestamp = mm_timestamp();
 	#endif
 
 	//no timers active
diff --git a/midimonster.h b/midimonster.h
index 1fc85b7..7f70f5b 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -26,7 +26,7 @@
 /* Default configuration file name to read when no other is specified */
 #define DEFAULT_CFG "monster.cfg"
 
-/* Forward declare some of the structs so we can use them in eachother */
+/* Forward declare some of the structs so we can use them in each other */
 struct _channel_value;
 struct _backend_channel;
 struct _backend_instance;
-- 
cgit v1.2.3


From 20a6882a063404858588596bd3f12bdd9e53460a Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 3 Aug 2019 18:42:39 +0200
Subject: Windows build compatiblity

---
 .gitignore              |  3 +++
 Makefile                | 23 +++++++++++++++++--
 backend.c               | 31 ++++++++++++++-----------
 backend.h               |  9 +++++++-
 backends/Makefile       | 26 +++++++++++++++++++--
 backends/artnet.c       | 16 ++++++++-----
 backends/artnet.h       |  2 ++
 backends/libmmbackend.c | 12 ++++++++--
 backends/libmmbackend.h |  6 +++++
 backends/lua.c          |  4 ----
 backends/osc.c          | 18 +++++++++------
 backends/osc.h          |  2 ++
 backends/sacn.c         | 28 ++++++++++++++---------
 backends/sacn.h         |  1 -
 config.c                | 56 +++++++++++++++++++++++++++++++++++++++++++++
 midimonster.c           | 39 ++++++++++++++++++++++++++------
 midimonster.h           | 38 ++++++++++++++++++++++++-------
 monster.cfg             | 12 +++-------
 plugin.c                | 60 +++++++++++++++++++++++++++++++++++++++++++++----
 portability.h           | 17 ++++++++++++++
 20 files changed, 326 insertions(+), 77 deletions(-)

(limited to 'midimonster.h')

diff --git a/.gitignore b/.gitignore
index 3afd872..4396a38 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
 midimonster
+midimonster.exe
+libmmapi.a
 *.swp
 *.o
 *.so
+*.dll
diff --git a/Makefile b/Makefile
index 5ee9cd9..b82d6d8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,10 +1,14 @@
-.PHONY: all clean run sanitize backends full backends-full
+.PHONY: all clean run sanitize backends windows full backends-full
 OBJS = config.o backend.o plugin.o
 PLUGINDIR = "\"./backends/\""
+PLUGINDIR_W32 = "\"backends\\\\\""
 
 SYSTEM := $(shell uname -s)
 
-CFLAGS ?= -g -Wall
+CFLAGS ?= -g -Wall -Wpedantic
+# Hide all non-API symbols for export
+CFLAGS += -fvisibility=hidden
+
 #CFLAGS += -DDEBUG
 midimonster: LDLIBS = -ldl
 midimonster: CFLAGS += -DPLUGINS=$(PLUGINDIR)
@@ -21,6 +25,8 @@ all: midimonster backends
 
 full: midimonster backends-full
 
+windows: midimonster.exe
+
 backends:
 	$(MAKE) -C backends
 
@@ -31,8 +37,21 @@ backends-full:
 midimonster: midimonster.c portability.h $(OBJS)
 	$(CC) $(CFLAGS) $(LDFLAGS) $< $(OBJS) $(LDLIBS) -o $@
 
+midimonster.exe: export CC = x86_64-w64-mingw32-gcc
+#midimonster.exe: CFLAGS += -Wno-format
+midimonster.exe: CFLAGS += -DPLUGINS=$(PLUGINDIR_W32) -Wno-format
+midimonster.exe: LDLIBS = -lws2_32
+midimonster.exe: LDFLAGS += -Wl,--out-implib,libmmapi.a
+midimonster.exe: midimonster.c portability.h $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $< $(OBJS) $(LDLIBS) -o $@
+	# The windows build for backends requires the import library generated with the build,
+	# so the backends can't be a prerequisite for the executable...
+	$(MAKE) -C backends windows
+
 clean:
 	$(RM) midimonster
+	$(RM) midimonster.exe
+	$(RM) libmmapi.a
 	$(RM) $(OBJS)
 	$(MAKE) -C backends clean
 
diff --git a/backend.c b/backend.c
index 5df5d73..4fa7704 100644
--- a/backend.c
+++ b/backend.c
@@ -1,4 +1,9 @@
 #include <string.h>
+#ifndef _WIN32
+#define MM_API __attribute__((visibility ("default")))
+#else
+#define MM_API __attribute__((dllexport))
+#endif
 #include "midimonster.h"
 #include "backend.h"
 
@@ -26,7 +31,7 @@ int backends_handle(size_t nfds, managed_fd* fds){
 			}
 		}
 
-		DBGPF("Notifying backend %s of %zu waiting FDs\n", backends[u].name, n);
+		DBGPF("Notifying backend %s of %lu waiting FDs\n", backends[u].name, n);
 		rv |= backends[u].process(n, fds);
 		if(rv){
 			fprintf(stderr, "Backend %s failed to handle input\n", backends[u].name);
@@ -59,28 +64,28 @@ int backends_notify(size_t nev, channel** c, channel_value* v){
 			}
 		}
 
-		DBGPF("Calling handler for instance %s with %zu events\n", instances[u]->name, n);
+		DBGPF("Calling handler for instance %s with %lu events\n", instances[u]->name, n);
 		rv |= instances[u]->backend->handle(instances[u], n, c, v);
 	}
 
 	return 0;
 }
 
-channel* mm_channel(instance* i, uint64_t ident, uint8_t create){
+channel* MM_API mm_channel(instance* inst, uint64_t ident, uint8_t create){
 	size_t u;
 	for(u = 0; u < nchannels; u++){
-		if(channels[u]->instance == i && channels[u]->ident == ident){
-			DBGPF("Requested channel %zu on instance %s already exists, reusing\n", ident, i->name);
+		if(channels[u]->instance == inst && channels[u]->ident == ident){
+			DBGPF("Requested channel %lu on instance %s already exists, reusing\n", ident, inst->name);
 			return channels[u];
 		}
 	}
 
 	if(!create){
-		DBGPF("Requested unknown channel %zu on instance %s\n", ident, i->name);
+		DBGPF("Requested unknown channel %lu on instance %s\n", ident, inst->name);
 		return NULL;
 	}
 
-	DBGPF("Creating previously unknown channel %zu on instance %s\n", ident, i->name);
+	DBGPF("Creating previously unknown channel %lu on instance %s\n", ident, inst->name);
 	channel** new_chan = realloc(channels, (nchannels + 1) * sizeof(channel*));
 	if(!new_chan){
 		fprintf(stderr, "Failed to allocate memory\n");
@@ -95,12 +100,12 @@ channel* mm_channel(instance* i, uint64_t ident, uint8_t create){
 		return NULL;
 	}
 
-	channels[nchannels]->instance = i;
+	channels[nchannels]->instance = inst;
 	channels[nchannels]->ident = ident;
 	return channels[nchannels++];
 }
 
-instance* mm_instance(){
+instance* MM_API mm_instance(){
 	instance** new_inst = realloc(instances, (ninstances + 1) * sizeof(instance*));
 	if(!new_inst){
 		//TODO free
@@ -118,7 +123,7 @@ instance* mm_instance(){
 	return instances[ninstances++];
 }
 
-instance* mm_instance_find(char* name, uint64_t ident){
+instance* MM_API mm_instance_find(char* name, uint64_t ident){
 	size_t u;
 	backend* b = backend_match(name);
 	if(!b){
@@ -134,7 +139,7 @@ instance* mm_instance_find(char* name, uint64_t ident){
 	return NULL;
 }
 
-int mm_backend_instances(char* name, size_t* ninst, instance*** inst){
+int MM_API mm_backend_instances(char* name, size_t* ninst, instance*** inst){
 	backend* b = backend_match(name);
 	size_t n = 0, u;
 	//count number of affected instances
@@ -177,7 +182,7 @@ void instances_free(){
 void channels_free(){
 	size_t u;
 	for(u = 0; u < nchannels; u++){
-		DBGPF("Destroying channel %zu on instance %s\n", channels[u]->ident, channels[u]->instance->name);
+		DBGPF("Destroying channel %lu on instance %s\n", channels[u]->ident, channels[u]->instance->name);
 		if(channels[u]->impl){
 			channels[u]->instance->backend->channel_free(channels[u]);
 		}
@@ -232,7 +237,7 @@ struct timeval backend_timeout(){
 	return tv;
 }
 
-int mm_backend_register(backend b){
+int MM_API mm_backend_register(backend b){
 	if(!backend_match(b.name)){
 		backends = realloc(backends, (nbackends + 1) * sizeof(backend));
 		if(!backends){
diff --git a/backend.h b/backend.h
index daf96bc..7529154 100644
--- a/backend.h
+++ b/backend.h
@@ -1,8 +1,8 @@
 #include <sys/types.h>
 
+/* Internal API */
 int backends_handle(size_t nfds, managed_fd* fds);
 int backends_notify(size_t nev, channel** c, channel_value* v);
-
 backend* backend_match(char* name);
 instance* instance_match(char* name);
 struct timeval backend_timeout();
@@ -10,3 +10,10 @@ int backends_start();
 int backends_stop();
 void instances_free();
 void channels_free();
+
+/* Backend API */
+channel* MM_API mm_channel(instance* inst, uint64_t ident, uint8_t create);
+instance* MM_API mm_instance();
+instance* MM_API mm_instance_find(char* name, uint64_t ident);
+int MM_API mm_backend_instances(char* name, size_t* ninst, instance*** inst);
+int MM_API mm_backend_register(backend b);
diff --git a/backends/Makefile b/backends/Makefile
index 22cb95b..2374df0 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -1,12 +1,13 @@
 .PHONY: all clean full
 OPTIONAL_BACKENDS = ola.so
+WINDOWS_BACKENDS = loopback.dll artnet.dll osc.dll sacn.dll
 LINUX_BACKENDS = midi.so evdev.so
 BACKENDS = artnet.so osc.so loopback.so sacn.so lua.so
 BACKEND_LIB = libmmbackend.o
 
 SYSTEM := $(shell uname -s)
 
-CFLAGS += -g -fPIC -I../
+CFLAGS += -g -fPIC -I../ -Wall -Wpedantic
 CPPFLAGS += -g -fPIC -I../
 LDFLAGS += -shared
 
@@ -20,8 +21,17 @@ LDFLAGS += -undefined dynamic_lookup
 endif
 
 artnet.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
+artnet.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
+artnet.dll: LDLIBS += -lws2_32
+
 osc.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
+osc.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
+osc.dll: LDLIBS += -lws2_32
+
 sacn.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
+sacn.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
+sacn.dll: LDLIBS += -lws2_32
+
 midi.so: LDLIBS = -lasound
 evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev)
 evdev.so: LDLIBS = $(shell pkg-config --libs libevdev)
@@ -33,12 +43,24 @@ lua.so: LDLIBS += $(shell pkg-config --libs lua5.3)
 %.so :: %.c %.h $(BACKEND_LIB)
 	$(CC) $(CFLAGS) $(LDLIBS) $< $(ADDITIONAL_OBJS) -o $@ $(LDFLAGS)
 
+%.dll :: %.c %.h $(BACKEND_LIB)
+	$(CC) $(CFLAGS) $< $(ADDITIONAL_OBJS) -o $@ $(LDFLAGS) $(LDLIBS)
+
 %.so :: %.cpp %.h
 	$(CXX) $(CPPFLAGS) $(LDLIBS) $< $(ADDITIONAL_OBJS) -o $@ $(LDFLAGS)
 
 all: $(BACKEND_LIB) $(BACKENDS)
 
+../libmmapi.a:
+	$(MAKE) -C ../ midimonster.exe
+
+windows: export CC = x86_64-w64-mingw32-gcc
+windows: LDLIBS += -lmmapi
+windows: LDFLAGS += -L../
+windows: CFLAGS += -Wno-format -Wno-pointer-sign
+windows: ../libmmapi.a $(BACKEND_LIB) $(WINDOWS_BACKENDS)
+
 full: $(BACKEND_LIB) $(BACKENDS) $(OPTIONAL_BACKENDS)
 
 clean:
-	$(RM) $(BACKEND_LIB) $(BACKENDS) $(OPTIONAL_BACKENDS)
+	$(RM) $(BACKEND_LIB) $(BACKENDS) $(OPTIONAL_BACKENDS) $(WINDOWS_BACKENDS)
diff --git a/backends/artnet.c b/backends/artnet.c
index 8b404a6..a6df4ab 100644
--- a/backends/artnet.c
+++ b/backends/artnet.c
@@ -3,8 +3,8 @@
 #include <errno.h>
 
 #include "libmmbackend.h"
-
 #include "artnet.h"
+
 #define MAX_FDS 255
 #define BACKEND_NAME "artnet"
 
@@ -32,7 +32,7 @@ static int artnet_listener(char* host, char* port){
 		return -1;
 	}
 
-	fprintf(stderr, "ArtNet backend interface %zu bound to %s port %s\n", artnet_fds, host, port);
+	fprintf(stderr, "ArtNet backend interface %lu bound to %s port %s\n", artnet_fds, host, port);
 	artnet_fd[artnet_fds].fd = fd;
 	artnet_fd[artnet_fds].output_instances = 0;
 	artnet_fd[artnet_fds].output_instance = NULL;
@@ -212,7 +212,7 @@ static int artnet_transmit(instance* inst){
 	};
 	memcpy(frame.data, data->data.out, 512);
 
-	if(sendto(artnet_fd[data->fd_index].fd, &frame, sizeof(frame), 0, (struct sockaddr*) &data->dest_addr, data->dest_len) < 0){
+	if(sendto(artnet_fd[data->fd_index].fd, (uint8_t*) &frame, sizeof(frame), 0, (struct sockaddr*) &data->dest_addr, data->dest_len) < 0){
 		fprintf(stderr, "Failed to output ArtNet frame for instance %s: %s\n", inst->name, strerror(errno));
 	}
 
@@ -230,7 +230,7 @@ static int artnet_set(instance* inst, size_t num, channel** c, channel_value* v)
 	artnet_instance_data* data = (artnet_instance_data*) inst->impl;
 
 	if(!data->dest_len){
-		fprintf(stderr, "ArtNet instance %s not enabled for output (%zu channel events)\n", inst->name, num);
+		fprintf(stderr, "ArtNet instance %s not enabled for output (%lu channel events)\n", inst->name, num);
 		return 0;
 	}
 
@@ -295,7 +295,7 @@ static inline int artnet_process_frame(instance* inst, artnet_pkt* frame){
 			}
 
 			if(!chan){
-				fprintf(stderr, "Active channel %zu on %s not known to core\n", p, inst->name);
+				fprintf(stderr, "Active channel %lu on %s not known to core\n", p, inst->name);
 				return 1;
 			}
 
@@ -367,7 +367,11 @@ static int artnet_handle(size_t num, managed_fd* fds){
 			}
 		} while(bytes_read > 0);
 
+		#ifdef _WIN32
+		if(bytes_read < 0 && WSAGetLastError() != WSAEWOULDBLOCK){
+		#else
 		if(bytes_read < 0 && errno != EAGAIN){
+		#endif
 			fprintf(stderr, "ArtNet failed to receive data: %s\n", strerror(errno));
 		}
 
@@ -438,7 +442,7 @@ static int artnet_start(){
 		}
 	}
 
-	fprintf(stderr, "ArtNet backend registering %zu descriptors to core\n", artnet_fds);
+	fprintf(stderr, "ArtNet backend registering %lu descriptors to core\n", artnet_fds);
 	for(u = 0; u < artnet_fds; u++){
 		if(mm_manage_fd(artnet_fd[u].fd, BACKEND_NAME, 1, (void*) u)){
 			goto bail;
diff --git a/backends/artnet.h b/backends/artnet.h
index 90aedd5..f5aa745 100644
--- a/backends/artnet.h
+++ b/backends/artnet.h
@@ -1,4 +1,6 @@
+#ifndef _WIN32
 #include <sys/socket.h>
+#endif
 #include "midimonster.h"
 
 int init();
diff --git a/backends/libmmbackend.c b/backends/libmmbackend.c
index 6320611..b27ebc5 100644
--- a/backends/libmmbackend.c
+++ b/backends/libmmbackend.c
@@ -53,7 +53,7 @@ int mmbackend_parse_sockaddr(char* host, char* port, struct sockaddr_storage* ad
 }
 
 int mmbackend_socket(char* host, char* port, int socktype, uint8_t listener){
-	int fd = -1, status, yes = 1, flags;
+	int fd = -1, status, yes = 1;
 	struct addrinfo hints = {
 		.ai_family = AF_UNSPEC,
 		.ai_socktype = socktype,
@@ -106,12 +106,20 @@ int mmbackend_socket(char* host, char* port, int socktype, uint8_t listener){
 	}
 
 	//set nonblocking
-	flags = fcntl(fd, F_GETFL, 0);
+	#ifdef _WIN32
+		u_long mode = 1;
+		if(ioctlsocket(fd, FIONBIO, &mode) != NO_ERROR){
+			closesocket(fd);
+			return 1;
+		}
+	#else
+	int flags = fcntl(fd, F_GETFL, 0);
 	if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0){
 		fprintf(stderr, "Failed to set socket nonblocking\n");
 		close(fd);
 		return -1;
 	}
+	#endif
 
 	return fd;
 }
diff --git a/backends/libmmbackend.h b/backends/libmmbackend.h
index 38bfca0..77cad6a 100644
--- a/backends/libmmbackend.h
+++ b/backends/libmmbackend.h
@@ -1,14 +1,20 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/types.h>
+#ifdef _WIN32
+#include <ws2tcpip.h>
+//#define close closesocket
+#else
 #include <sys/socket.h>
 #include <netdb.h>
+#endif
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include "../portability.h"
 
 /* Parse spec as host specification in the form
  *	host port
diff --git a/backends/lua.c b/backends/lua.c
index 4a910a2..ec02575 100644
--- a/backends/lua.c
+++ b/backends/lua.c
@@ -161,8 +161,6 @@ static int lua_callback_output(lua_State* interpreter){
 
 static int lua_callback_interval(lua_State* interpreter){
 	size_t n = 0;
-	instance* inst = NULL;
-	lua_instance_data* data = NULL;
 	uint64_t interval = 0;
 	int reference = LUA_NOREF;
 
@@ -174,8 +172,6 @@ static int lua_callback_interval(lua_State* interpreter){
 	//get instance pointer from registry
 	lua_pushstring(interpreter, LUA_REGISTRY_KEY);
 	lua_gettable(interpreter, LUA_REGISTRYINDEX);
-	inst = (instance*) lua_touserdata(interpreter, -1);
-	data = (lua_instance_data*) inst->impl;
 
 	//fetch and round the interval
 	interval = luaL_checkinteger(interpreter, 2);
diff --git a/backends/osc.c b/backends/osc.c
index 18c8bad..03e431f 100644
--- a/backends/osc.c
+++ b/backends/osc.c
@@ -1,8 +1,8 @@
 #include <string.h>
 #include <ctype.h>
 #include <errno.h>
-#include "libmmbackend.h"
 
+#include "libmmbackend.h"
 #include "osc.h"
 
 /*
@@ -480,14 +480,14 @@ static int osc_register_pattern(osc_instance_data* data, char* pattern_path, cha
 		//parse min/max values
 		token = strtok(NULL, " ");
 		if(!token){
-			fprintf(stderr, "Missing minimum specification for parameter %zu of OSC pattern %s\n", u, pattern_path);
+			fprintf(stderr, "Missing minimum specification for parameter %lu of OSC pattern %s\n", u, pattern_path);
 			return 1;
 		}
 		data->pattern[pattern].min[u] = osc_parse_value_spec(format[u], token);
 
 		token = strtok(NULL, " ");
 		if(!token){
-			fprintf(stderr, "Missing maximum specification for parameter %zu of OSC pattern %s\n", u, pattern_path);
+			fprintf(stderr, "Missing maximum specification for parameter %lu of OSC pattern %s\n", u, pattern_path);
 			return 1;
 		}
 		data->pattern[pattern].max[u] = osc_parse_value_spec(format[u], token);
@@ -689,7 +689,7 @@ static int osc_output_channel(instance* inst, size_t channel){
 
 		//write data
 		if(offset + osc_data_length(data->channel[channel].type[p]) >= sizeof(xmit_buf)){
-			fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s at parameter %zu\n", inst->name, data->channel[channel].path, p);
+			fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s at parameter %lu\n", inst->name, data->channel[channel].path, p);
 			return 1;
 		}
 
@@ -720,7 +720,7 @@ static int osc_set(instance* inst, size_t num, channel** c, channel_value* v){
 
 	osc_instance_data* data = (osc_instance_data*) inst->impl;
 	if(!data->dest_len){
-		fprintf(stderr, "OSC instance %s does not have a destination, output is disabled (%zu channels)\n", inst->name, num);
+		fprintf(stderr, "OSC instance %s does not have a destination, output is disabled (%lu channels)\n", inst->name, num);
 		return 0;
 	}
 
@@ -778,7 +778,7 @@ static int osc_process_packet(instance* inst, char* local_path, char* format, ui
 	channel* chan = NULL;
 
 	if(payload_len % 4){
-		fprintf(stderr, "Invalid OSC packet, data length %zu\n", payload_len);
+		fprintf(stderr, "Invalid OSC packet, data length %lu\n", payload_len);
 		return 0;
 	}
 
@@ -877,7 +877,11 @@ static int osc_handle(size_t num, managed_fd* fds){
 			}
 		} while(bytes_read > 0);
 
+		#ifdef _WIN32
+		if(bytes_read < 0 && WSAGetLastError() != WSAEWOULDBLOCK){
+		#else
 		if(bytes_read < 0 && errno != EAGAIN){
+		#endif
 			fprintf(stderr, "OSC failed to receive data for instance %s: %s\n", inst->name, strerror(errno));
 		}
 
@@ -924,7 +928,7 @@ static int osc_start(){
 		}
 	}
 
-	fprintf(stderr, "OSC backend registered %zu descriptors to core\n", fds);
+	fprintf(stderr, "OSC backend registered %lu descriptors to core\n", fds);
 
 	free(inst);
 	return 0;
diff --git a/backends/osc.h b/backends/osc.h
index 4e9dec5..b2aaea7 100644
--- a/backends/osc.h
+++ b/backends/osc.h
@@ -1,6 +1,8 @@
 #include "midimonster.h"
 #include <sys/types.h>
+#ifndef _WIN32
 #include <sys/socket.h>
+#endif
 
 #define OSC_RECV_BUF 8192
 #define OSC_XMIT_BUF 8192
diff --git a/backends/sacn.c b/backends/sacn.c
index 75bb76f..6f7d1a5 100644
--- a/backends/sacn.c
+++ b/backends/sacn.c
@@ -1,16 +1,18 @@
 #include <string.h>
 #include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <ctype.h>
+#ifndef _WIN32
+#include <netdb.h>
 #include <netinet/in.h>
+#include <sys/socket.h>
+#endif
 
 #include "libmmbackend.h"
-
 #include "sacn.h"
+
 //upper limit imposed by using the fd index as 16-bit part of the instance id
 #define MAX_FDS 4096
 #define BACKEND_NAME "sacn"
@@ -71,7 +73,7 @@ static int sacn_listener(char* host, char* port, uint8_t fd_flags){
 		return -1;
 	}
 
-	fprintf(stderr, "sACN backend interface %zu bound to %s port %s\n", global_cfg.fds, host, port);
+	fprintf(stderr, "sACN backend interface %lu bound to %s port %s\n", global_cfg.fds, host, port);
 	global_cfg.fd[global_cfg.fds].fd = fd;
 	global_cfg.fd[global_cfg.fds].flags = fd_flags;
 	global_cfg.fd[global_cfg.fds].universes = 0;
@@ -271,7 +273,7 @@ static int sacn_transmit(instance* inst){
 	memcpy(pdu.data.source_name, global_cfg.source_name, sizeof(pdu.data.source_name));
 	memcpy((((uint8_t*)pdu.data.data) + 1), data->data.out, 512);
 
-	if(sendto(global_cfg.fd[data->fd_index].fd, &pdu, sizeof(pdu), 0, (struct sockaddr*) &data->dest_addr, data->dest_len) < 0){
+	if(sendto(global_cfg.fd[data->fd_index].fd, (uint8_t*) &pdu, sizeof(pdu), 0, (struct sockaddr*) &data->dest_addr, data->dest_len) < 0){
 		fprintf(stderr, "Failed to output sACN frame for instance %s: %s\n", inst->name, strerror(errno));
 	}
 
@@ -293,7 +295,7 @@ static int sacn_set(instance* inst, size_t num, channel** c, channel_value* v){
 	}
 
 	if(!data->xmit_prio){
-		fprintf(stderr, "sACN instance %s not enabled for output (%zu channel events)\n", inst->name, num);
+		fprintf(stderr, "sACN instance %s not enabled for output (%lu channel events)\n", inst->name, num);
 		return 0;
 	}
 
@@ -378,7 +380,7 @@ static int sacn_process_frame(instance* inst, sacn_frame_root* frame, sacn_frame
 			}
 
 			if(!chan){
-				fprintf(stderr, "Active channel %zu on %s not known to core", u, inst->name);
+				fprintf(stderr, "Active channel %lu on %s not known to core", u, inst->name);
 				return 1;
 			}
 
@@ -445,8 +447,8 @@ static void sacn_discovery(size_t fd){
 		pdu.data.page = page;
 		memcpy(pdu.data.data, global_cfg.fd[fd].universe + page * 512, universes * sizeof(uint16_t));
 
-		if(sendto(global_cfg.fd[fd].fd, &pdu, sizeof(pdu) - (512 - universes) * sizeof(uint16_t), 0, (struct sockaddr*) &discovery_dest, sizeof(discovery_dest)) < 0){
-			fprintf(stderr, "Failed to output sACN universe discovery frame for interface %zu: %s\n", fd, strerror(errno));
+		if(sendto(global_cfg.fd[fd].fd, (uint8_t*) &pdu, sizeof(pdu) - (512 - universes) * sizeof(uint16_t), 0, (struct sockaddr*) &discovery_dest, sizeof(discovery_dest)) < 0){
+			fprintf(stderr, "Failed to output sACN universe discovery frame for interface %lu: %s\n", fd, strerror(errno));
 		}
 	}
 }
@@ -512,7 +514,11 @@ static int sacn_handle(size_t num, managed_fd* fds){
 			}
 		} while(bytes_read > 0);
 
+		#ifdef _WIN32
+		if(bytes_read < 0 && WSAGetLastError() != WSAEWOULDBLOCK){
+		#else
 		if(bytes_read < 0 && errno != EAGAIN){
+		#endif
 			fprintf(stderr, "sACN failed to receive data: %s\n", strerror(errno));
 		}
 
@@ -577,7 +583,7 @@ static int sacn_start(){
 
 		if(!data->unicast_input){
 			mcast_req.imr_multiaddr.s_addr = htobe32(((uint32_t) 0xefff0000) | ((uint32_t) data->uni));
-			if(setsockopt(global_cfg.fd[data->fd_index].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mcast_req, sizeof(mcast_req))){
+			if(setsockopt(global_cfg.fd[data->fd_index].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (uint8_t*) &mcast_req, sizeof(mcast_req))){
 				fprintf(stderr, "Failed to join Multicast group for sACN universe %u on instance %s: %s\n", data->uni, inst[u]->name, strerror(errno));
 			}
 		}
@@ -604,7 +610,7 @@ static int sacn_start(){
 		}
 	}
 
-	fprintf(stderr, "sACN backend registering %zu descriptors to core\n", global_cfg.fds);
+	fprintf(stderr, "sACN backend registering %lu descriptors to core\n", global_cfg.fds);
 	for(u = 0; u < global_cfg.fds; u++){
 		//allocate memory for storing last frame transmission timestamp
 		global_cfg.fd[u].last_frame = calloc(global_cfg.fd[u].universes, sizeof(uint64_t));
diff --git a/backends/sacn.h b/backends/sacn.h
index e7106f7..7af2a36 100644
--- a/backends/sacn.h
+++ b/backends/sacn.h
@@ -1,4 +1,3 @@
-#include <sys/socket.h>
 #include "midimonster.h"
 
 int init();
diff --git a/config.c b/config.c
index 6d5fd16..93fb56d 100644
--- a/config.c
+++ b/config.c
@@ -20,6 +20,62 @@ typedef enum {
 static backend* current_backend = NULL;
 static instance* current_instance = NULL;
 
+#ifdef _WIN32
+#define GETLINE_BUFFER 4096
+
+static ssize_t getline(char** line, size_t* alloc, FILE* stream){
+	size_t bytes_read = 0;
+	char c;
+	//sanity checks
+	if(!line || !alloc || !stream){
+		return -1;
+	}
+
+	//allocate buffer if none provided
+	if(!*line || !*alloc){
+		*alloc = GETLINE_BUFFER;
+		*line = calloc(GETLINE_BUFFER, sizeof(char));
+		if(!*line){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return -1;
+		}
+	}
+
+	if(feof(stream)){
+		return -1;
+	}
+
+	for(c = fgetc(stream); 1; c = fgetc(stream)){
+		//end of buffer, resize
+		if(bytes_read == (*alloc) - 1){
+			*alloc += GETLINE_BUFFER;
+			*line = realloc(*line, (*alloc) * sizeof(char));
+			if(!*line){
+				fprintf(stderr, "Failed to allocate memory\n");
+				return -1;
+			}
+		}
+
+		//store character
+		(*line)[bytes_read] = c;
+
+		//end of line
+		if(feof(stream) || c == '\n'){
+			//terminate string
+			(*line)[bytes_read + 1] = 0;
+			return bytes_read;
+		}
+
+		//input broken
+		if(ferror(stream) || c < 0){
+			return -1;
+		}
+
+		bytes_read++;
+	}
+}
+#endif
+
 static char* config_trim_line(char* in){
 	ssize_t n;
 	//trim front
diff --git a/midimonster.c b/midimonster.c
index fb664a4..df27ca3 100644
--- a/midimonster.c
+++ b/midimonster.c
@@ -1,9 +1,14 @@
 #include <string.h>
 #include <signal.h>
-#include <sys/select.h>
 #include <unistd.h>
 #include <errno.h>
 #include <time.h>
+#ifndef _WIN32
+#include <sys/select.h>
+#define MM_API __attribute__((visibility("default")))
+#else
+#define MM_API __attribute__((dllexport))
+#endif
 #include "midimonster.h"
 #include "config.h"
 #include "backend.h"
@@ -35,11 +40,14 @@ static void signal_handler(int signum){
 	shutdown_requested = 1;
 }
 
-uint64_t mm_timestamp(){
+uint64_t MM_API mm_timestamp(){
 	return global_timestamp;
 }
 
 static void update_timestamp(){
+	#ifdef _WIN32
+	global_timestamp = GetTickCount();
+	#else
 	struct timespec current;
 	if(clock_gettime(CLOCK_MONOTONIC_COARSE, &current)){
 		fprintf(stderr, "Failed to update global timestamp, time-based processing for some backends may be impaired: %s\n", strerror(errno));
@@ -47,6 +55,7 @@ static void update_timestamp(){
 	}
 
 	global_timestamp = current.tv_sec * 1000 + current.tv_nsec / 1000000;
+	#endif
 }
 
 int mm_map_channel(channel* from, channel* to){
@@ -99,7 +108,7 @@ void map_free(){
 	map = NULL;
 }
 
-int mm_manage_fd(int new_fd, char* back, int manage, void* impl){
+int MM_API mm_manage_fd(int new_fd, char* back, int manage, void* impl){
 	backend* b = backend_match(back);
 	size_t u;
 
@@ -163,7 +172,7 @@ void fds_free(){
 	fd = NULL;
 }
 
-int mm_channel_event(channel* c, channel_value v){
+int MM_API mm_channel_event(channel* c, channel_value v){
 	size_t u, p;
 
 	//find mapped channels
@@ -229,7 +238,7 @@ static fd_set fds_collect(int* max_fd){
 		*max_fd = -1;
 	}
 
-	DBGPF("Building selector set from %zu FDs registered to core\n", fds);
+	DBGPF("Building selector set from %lu FDs registered to core\n", fds);
 	FD_ZERO(&rv_fds);
 	for(u = 0; u < fds; u++){
 		if(fd[u].fd >= 0){
@@ -243,6 +252,17 @@ static fd_set fds_collect(int* max_fd){
 	return rv_fds;
 }
 
+int platform_initialize(){
+#ifdef _WIN32
+	WSADATA wsa;
+	WORD version = MAKEWORD(2, 2);
+	if(WSAStartup(version, &wsa)){
+		return 1;
+	}
+#endif
+	return 0;
+}
+
 int main(int argc, char** argv){
 	fd_set all_fds, read_fds;
 	event_collection* secondary = NULL;
@@ -255,6 +275,11 @@ int main(int argc, char** argv){
 		cfg_file = argv[1];
 	}
 
+	if(platform_initialize()){
+		fprintf(stderr, "Failed to perform platform-specific initialization\n");
+		return EXIT_FAILURE;
+	}
+
 	FD_ZERO(&all_fds);
 	//initialize backends
 	if(plugins_load(PLUGINS)){
@@ -316,14 +341,14 @@ int main(int argc, char** argv){
 		update_timestamp();
 
 		//run backend processing, collect events
-		DBGPF("%zu backend FDs signaled\n", n);
+		DBGPF("%lu backend FDs signaled\n", n);
 		if(backends_handle(n, signaled_fds)){
 			goto bail;
 		}
 
 		while(primary->n){
 			//swap primary and secondary event collectors
-			DBGPF("Swapping event collectors, %zu events in primary\n", primary->n);
+			DBGPF("Swapping event collectors, %lu events in primary\n", primary->n);
 			for(u = 0; u < sizeof(event_pool) / sizeof(event_collection); u++){
 				if(primary != event_pool + u){
 					secondary = primary;
diff --git a/midimonster.h b/midimonster.h
index 7f70f5b..eb118c6 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -4,6 +4,21 @@
 #include <stdlib.h>
 #include <stdint.h>
 
+#ifndef MM_API
+	#ifdef _WIN32
+		#define MM_API __attribute__((dllimport))
+	#else
+		#define MM_API
+	#endif
+#endif
+
+/* GCC ignores the visibility attributes on some API functions, so override visibility */
+#if !defined(_WIN32) && defined(__GNUC__) && !defined(__clang__)
+	#undef MM_API
+	#define MM_API
+	#pragma GCC visibility push(default)
+#endif
+
 /* Straight-forward min / max macros */
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #define min(a,b) (((a) < (b)) ? (a) : (b))
@@ -187,7 +202,7 @@ typedef struct /*_mm_channel_mapping*/ {
 /*
  * Register a new backend.
  */
-int mm_backend_register(backend b);
+int MM_API mm_backend_register(backend b);
 
 /*
  * Provides a pointer to a newly (zero-)allocated instance.
@@ -201,7 +216,8 @@ int mm_backend_register(backend b);
  * mmbackend_shutdown procedure of the backend, eg. by querying
  * all instances for the backend.
  */
-instance* mm_instance();
+instance* MM_API mm_instance();
+
 /*
  * Finds an instance matching the specified backend and identifier.
  * Since setting an identifier for an instance is optional,
@@ -209,7 +225,8 @@ instance* mm_instance();
  * Instance identifiers may for example be set in the backends
  * mmbackend_start call.
  */
-instance* mm_instance_find(char* backend, uint64_t ident);
+instance* MM_API mm_instance_find(char* backend, uint64_t ident);
+
 /*
  * Provides a pointer to a channel structure, pre-filled with
  * the provided instance reference and identifier.
@@ -224,30 +241,35 @@ instance* mm_instance_find(char* backend, uint64_t ident);
  * this function, the backend will receive a call to its channel_free
  * function.
  */
-channel* mm_channel(instance* i, uint64_t ident, uint8_t create);
+channel* MM_API mm_channel(instance* i, uint64_t ident, uint8_t create);
 //TODO channel* mm_channel_find()
+
 /*
  * Register (manage = 1) or unregister (manage = 0) a file descriptor
  * to be selected on. The backend will be notified when the descriptor
  * becomes ready to read via its registered mmbackend_process_fd call.
  */
-int mm_manage_fd(int fd, char* backend, int manage, void* impl);
+int MM_API mm_manage_fd(int fd, char* backend, int manage, void* impl);
+
 /*
  * Notifies the core of a channel event. Called by backends to
  * inject events gathered from their backing implementation.
  */
-int mm_channel_event(channel* c, channel_value v);
+int MM_API mm_channel_event(channel* c, channel_value v);
+
 /*
  * Query all active instances for a given backend.
  * *i will need to be freed by the caller.
  */
-int mm_backend_instances(char* backend, size_t* n, instance*** i);
+int MM_API mm_backend_instances(char* backend, size_t* n, instance*** i);
+
 /*
  * Query an internal timestamp, which is updated every core iteration.
  * This timestamp should not be used as a performance counter, but can be
  * used for timeouting. Resolution is milliseconds.
  */
-uint64_t mm_timestamp();
+uint64_t MM_API mm_timestamp();
+
 /*
  * Create a channel-to-channel mapping. This API should not
  * be used by backends. It is only exported for core modules.
diff --git a/monster.cfg b/monster.cfg
index 2e6f76f..2413f6d 100644
--- a/monster.cfg
+++ b/monster.cfg
@@ -1,18 +1,12 @@
 [backend artnet]
 bind = 0.0.0.0
 
-[backend evdev]
+[loopback loop]
 
 [artnet art]
 universe = 0
 dest = 255.255.255.255
 
-[evdev mouse]
-input = TPPS
-
-[loopback loop]
-
 [map]
-mouse.EV_REL.REL_X > loop.chan0
-art.{3..4}{4..3} > loop.chan{4..3}{3..4}
-art.{1..10} > loop.data{1..10}
+
+art.1+2 > loop.b
diff --git a/plugin.c b/plugin.c
index fc642ac..a452559 100644
--- a/plugin.c
+++ b/plugin.c
@@ -1,11 +1,20 @@
 #include <stdio.h>
 #include <string.h>
-#include <dlfcn.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
+#include "portability.h"
+#ifdef _WIN32
+#define dlclose FreeLibrary
+#define dlsym GetProcAddress
+#define dlerror() "Failed"
+#define dlopen(lib,ig) LoadLibrary(lib)
+#else
+#include <dlfcn.h>
+#endif
+
 #include "plugin.h"
 
 static size_t plugins = 0;
@@ -14,19 +23,29 @@ static void** plugin_handle = NULL;
 static int plugin_attach(char* path, char* file){
 	plugin_init init = NULL;
 	void* handle = NULL;
+	char* lib = NULL;
+	char* error = NULL;
 
-	char* lib = calloc(strlen(path) + strlen(file) + 1, sizeof(char));
+	lib = calloc(strlen(path) + strlen(file) + 1, sizeof(char));
 	if(!lib){
 		fprintf(stderr, "Failed to allocate memory\n");
 		return 1;
 	}
-
 	snprintf(lib, strlen(path) + strlen(file) + 1, "%s%s", path, file);
 
 	handle = dlopen(lib, RTLD_NOW);
 	if(!handle){
-		fprintf(stderr, "Failed to load plugin %s: %s\n", lib, dlerror());
+		#ifdef _WIN32
+		FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &error, 0, NULL);
+		#else
+		error = dlerror();
+		#endif
+		fprintf(stderr, "Failed to load plugin %s: %s\n", lib, error);
 		free(lib);
+		#ifdef _WIN32
+		LocalFree(error);
+		#endif
 		return 0;
 	}
 
@@ -62,6 +81,38 @@ static int plugin_attach(char* path, char* file){
 int plugins_load(char* path){
 	int rv = -1;
 
+#ifdef _WIN32
+	char* search_expression = calloc(strlen(path) + strlen("*.dll") + 1, sizeof(char));
+	if(!search_expression){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return -1;
+	}
+	snprintf(search_expression, strlen(path) + strlen("*.dll"), "%s*.dll", path);
+
+	WIN32_FIND_DATA result;
+	HANDLE hSearch = FindFirstFile(search_expression, &result);
+
+	if(hSearch == INVALID_HANDLE_VALUE){
+		LPVOID lpMsgBuf = NULL;
+		FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
+		fprintf(stderr, "Failed to search for backend plugin files in %s: %s\n", path, lpMsgBuf);
+		LocalFree(lpMsgBuf);
+		return -1;
+	}
+
+	do {
+		if(plugin_attach(path, result.cFileName)){
+			goto load_done;
+		}
+	} while(FindNextFile(hSearch, &result));
+
+	rv = 0;
+load_done:
+	free(search_expression);
+	FindClose(hSearch);
+	return rv;
+#else
 	struct dirent* entry;
 	struct stat file_stat;
 	DIR* directory = opendir(path);
@@ -100,6 +151,7 @@ load_done:
 		return -1;
 	}
 	return rv;
+#endif
 }
 
 int plugins_close(){
diff --git a/portability.h b/portability.h
index 25aee01..903ecd8 100644
--- a/portability.h
+++ b/portability.h
@@ -19,3 +19,20 @@
 	#define be64toh(x) OSSwapBigToHostInt64(x)
 	#define le64toh(x) OSSwapLittleToHostInt64(x)
 #endif
+
+#ifdef _WIN32
+	#define WIN32_LEAN_AND_MEAN
+	#include <windows.h>
+	#include <winsock2.h>
+
+	#define htobe16(x) htons(x)
+	#define be16toh(x) ntohs(x)
+
+	#define htobe32(x) htonl(x)
+	#define be32toh(x) ntohl(x)
+
+	#define htobe64(x) _byteswap_uint64(x)
+	#define htole64(x) (x)
+	#define be64toh(x) _byteswap_uint64(x)
+	#define le64toh(x) (x)
+#endif
-- 
cgit v1.2.3


From 47a5f9a21bd661f9161d6175ebd074962daee255 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Wed, 7 Aug 2019 17:25:24 +0200
Subject: Fix export visibilities for GCC

---
 Makefile          |  5 +----
 backend.c         | 10 +++++-----
 backend.h         | 10 +++++-----
 backends/Makefile | 10 +++++++---
 backends/midi.c   |  6 ------
 midimonster.c     | 16 ++++++++--------
 midimonster.h     | 23 ++++++++---------------
 7 files changed, 34 insertions(+), 46 deletions(-)

(limited to 'midimonster.h')

diff --git a/Makefile b/Makefile
index b82d6d8..57fe089 100644
--- a/Makefile
+++ b/Makefile
@@ -26,6 +26,7 @@ all: midimonster backends
 full: midimonster backends-full
 
 windows: midimonster.exe
+	$(MAKE) -C backends windows
 
 backends:
 	$(MAKE) -C backends
@@ -38,15 +39,11 @@ midimonster: midimonster.c portability.h $(OBJS)
 	$(CC) $(CFLAGS) $(LDFLAGS) $< $(OBJS) $(LDLIBS) -o $@
 
 midimonster.exe: export CC = x86_64-w64-mingw32-gcc
-#midimonster.exe: CFLAGS += -Wno-format
 midimonster.exe: CFLAGS += -DPLUGINS=$(PLUGINDIR_W32) -Wno-format
 midimonster.exe: LDLIBS = -lws2_32
 midimonster.exe: LDFLAGS += -Wl,--out-implib,libmmapi.a
 midimonster.exe: midimonster.c portability.h $(OBJS)
 	$(CC) $(CFLAGS) $(LDFLAGS) $< $(OBJS) $(LDLIBS) -o $@
-	# The windows build for backends requires the import library generated with the build,
-	# so the backends can't be a prerequisite for the executable...
-	$(MAKE) -C backends windows
 
 clean:
 	$(RM) midimonster
diff --git a/backend.c b/backend.c
index 4fa7704..3a18f41 100644
--- a/backend.c
+++ b/backend.c
@@ -71,7 +71,7 @@ int backends_notify(size_t nev, channel** c, channel_value* v){
 	return 0;
 }
 
-channel* MM_API mm_channel(instance* inst, uint64_t ident, uint8_t create){
+MM_API channel* mm_channel(instance* inst, uint64_t ident, uint8_t create){
 	size_t u;
 	for(u = 0; u < nchannels; u++){
 		if(channels[u]->instance == inst && channels[u]->ident == ident){
@@ -105,7 +105,7 @@ channel* MM_API mm_channel(instance* inst, uint64_t ident, uint8_t create){
 	return channels[nchannels++];
 }
 
-instance* MM_API mm_instance(){
+MM_API instance* mm_instance(){
 	instance** new_inst = realloc(instances, (ninstances + 1) * sizeof(instance*));
 	if(!new_inst){
 		//TODO free
@@ -123,7 +123,7 @@ instance* MM_API mm_instance(){
 	return instances[ninstances++];
 }
 
-instance* MM_API mm_instance_find(char* name, uint64_t ident){
+MM_API instance* mm_instance_find(char* name, uint64_t ident){
 	size_t u;
 	backend* b = backend_match(name);
 	if(!b){
@@ -139,7 +139,7 @@ instance* MM_API mm_instance_find(char* name, uint64_t ident){
 	return NULL;
 }
 
-int MM_API mm_backend_instances(char* name, size_t* ninst, instance*** inst){
+MM_API int mm_backend_instances(char* name, size_t* ninst, instance*** inst){
 	backend* b = backend_match(name);
 	size_t n = 0, u;
 	//count number of affected instances
@@ -237,7 +237,7 @@ struct timeval backend_timeout(){
 	return tv;
 }
 
-int MM_API mm_backend_register(backend b){
+MM_API int mm_backend_register(backend b){
 	if(!backend_match(b.name)){
 		backends = realloc(backends, (nbackends + 1) * sizeof(backend));
 		if(!backends){
diff --git a/backend.h b/backend.h
index 7529154..6573e17 100644
--- a/backend.h
+++ b/backend.h
@@ -12,8 +12,8 @@ void instances_free();
 void channels_free();
 
 /* Backend API */
-channel* MM_API mm_channel(instance* inst, uint64_t ident, uint8_t create);
-instance* MM_API mm_instance();
-instance* MM_API mm_instance_find(char* name, uint64_t ident);
-int MM_API mm_backend_instances(char* name, size_t* ninst, instance*** inst);
-int MM_API mm_backend_register(backend b);
+MM_API channel* mm_channel(instance* inst, uint64_t ident, uint8_t create);
+MM_API instance* mm_instance();
+MM_API instance* mm_instance_find(char* name, uint64_t ident);
+MM_API int mm_backend_instances(char* name, size_t* ninst, instance*** inst);
+MM_API int mm_backend_register(backend b);
diff --git a/backends/Makefile b/backends/Makefile
index 2374df0..3308ef0 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -1,8 +1,8 @@
 .PHONY: all clean full
-OPTIONAL_BACKENDS = ola.so
-WINDOWS_BACKENDS = loopback.dll artnet.dll osc.dll sacn.dll
 LINUX_BACKENDS = midi.so evdev.so
-BACKENDS = artnet.so osc.so loopback.so sacn.so lua.so
+WINDOWS_BACKENDS = artnet.dll osc.dll loopback.dll sacn.dll maweb.dll
+BACKENDS = artnet.so osc.so loopback.so sacn.so lua.so maweb.so
+OPTIONAL_BACKENDS = ola.so
 BACKEND_LIB = libmmbackend.o
 
 SYSTEM := $(shell uname -s)
@@ -32,6 +32,10 @@ sacn.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
 sacn.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
 sacn.dll: LDLIBS += -lws2_32
 
+maweb.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
+maweb.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
+maweb.dll: LDLIBS += -lws2_32
+
 midi.so: LDLIBS = -lasound
 evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev)
 evdev.so: LDLIBS = $(shell pkg-config --libs libevdev)
diff --git a/backends/midi.c b/backends/midi.c
index c1480c0..9c6ba80 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -14,12 +14,6 @@ typedef union {
 	uint64_t label;
 } midi_channel_ident;
 
-/*
- * TODO
- * 	Optionally send note-off messages
- * 	Optionally send updates as after-touch
- */
-
 enum /*_midi_channel_type*/ {
 	none = 0,
 	note,
diff --git a/midimonster.c b/midimonster.c
index df27ca3..1e47698 100644
--- a/midimonster.c
+++ b/midimonster.c
@@ -40,7 +40,7 @@ static void signal_handler(int signum){
 	shutdown_requested = 1;
 }
 
-uint64_t MM_API mm_timestamp(){
+MM_API uint64_t mm_timestamp(){
 	return global_timestamp;
 }
 
@@ -98,7 +98,7 @@ int mm_map_channel(channel* from, channel* to){
 	return 0;
 }
 
-void map_free(){
+static void map_free(){
 	size_t u;
 	for(u = 0; u < mappings; u++){
 		free(map[u].to);
@@ -108,7 +108,7 @@ void map_free(){
 	map = NULL;
 }
 
-int MM_API mm_manage_fd(int new_fd, char* back, int manage, void* impl){
+MM_API int mm_manage_fd(int new_fd, char* back, int manage, void* impl){
 	backend* b = backend_match(back);
 	size_t u;
 
@@ -158,7 +158,7 @@ int MM_API mm_manage_fd(int new_fd, char* back, int manage, void* impl){
 	return 0;
 }
 
-void fds_free(){
+static void fds_free(){
 	size_t u;
 	for(u = 0; u < fds; u++){
 		//TODO free impl
@@ -172,7 +172,7 @@ void fds_free(){
 	fd = NULL;
 }
 
-int MM_API mm_channel_event(channel* c, channel_value v){
+MM_API int mm_channel_event(channel* c, channel_value v){
 	size_t u, p;
 
 	//find mapped channels
@@ -213,7 +213,7 @@ int MM_API mm_channel_event(channel* c, channel_value v){
 	return 0;
 }
 
-void event_free(){
+static void event_free(){
 	size_t u;
 
 	for(u = 0; u < sizeof(event_pool) / sizeof(event_collection); u++){
@@ -223,7 +223,7 @@ void event_free(){
 	}
 }
 
-int usage(char* fn){
+static int usage(char* fn){
 	fprintf(stderr, "MIDIMonster v0.1\n");
 	fprintf(stderr, "Usage:\n");
 	fprintf(stderr, "\t%s <configfile>\n", fn);
@@ -252,7 +252,7 @@ static fd_set fds_collect(int* max_fd){
 	return rv_fds;
 }
 
-int platform_initialize(){
+static int platform_initialize(){
 #ifdef _WIN32
 	WSADATA wsa;
 	WORD version = MAKEWORD(2, 2);
diff --git a/midimonster.h b/midimonster.h
index eb118c6..270a61f 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -12,13 +12,6 @@
 	#endif
 #endif
 
-/* GCC ignores the visibility attributes on some API functions, so override visibility */
-#if !defined(_WIN32) && defined(__GNUC__) && !defined(__clang__)
-	#undef MM_API
-	#define MM_API
-	#pragma GCC visibility push(default)
-#endif
-
 /* Straight-forward min / max macros */
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #define min(a,b) (((a) < (b)) ? (a) : (b))
@@ -202,7 +195,7 @@ typedef struct /*_mm_channel_mapping*/ {
 /*
  * Register a new backend.
  */
-int MM_API mm_backend_register(backend b);
+MM_API int mm_backend_register(backend b);
 
 /*
  * Provides a pointer to a newly (zero-)allocated instance.
@@ -216,7 +209,7 @@ int MM_API mm_backend_register(backend b);
  * mmbackend_shutdown procedure of the backend, eg. by querying
  * all instances for the backend.
  */
-instance* MM_API mm_instance();
+MM_API instance* mm_instance();
 
 /*
  * Finds an instance matching the specified backend and identifier.
@@ -225,7 +218,7 @@ instance* MM_API mm_instance();
  * Instance identifiers may for example be set in the backends
  * mmbackend_start call.
  */
-instance* MM_API mm_instance_find(char* backend, uint64_t ident);
+MM_API instance* mm_instance_find(char* backend, uint64_t ident);
 
 /*
  * Provides a pointer to a channel structure, pre-filled with
@@ -241,7 +234,7 @@ instance* MM_API mm_instance_find(char* backend, uint64_t ident);
  * this function, the backend will receive a call to its channel_free
  * function.
  */
-channel* MM_API mm_channel(instance* i, uint64_t ident, uint8_t create);
+MM_API channel* mm_channel(instance* i, uint64_t ident, uint8_t create);
 //TODO channel* mm_channel_find()
 
 /*
@@ -249,26 +242,26 @@ channel* MM_API mm_channel(instance* i, uint64_t ident, uint8_t create);
  * to be selected on. The backend will be notified when the descriptor
  * becomes ready to read via its registered mmbackend_process_fd call.
  */
-int MM_API mm_manage_fd(int fd, char* backend, int manage, void* impl);
+MM_API int mm_manage_fd(int fd, char* backend, int manage, void* impl);
 
 /*
  * Notifies the core of a channel event. Called by backends to
  * inject events gathered from their backing implementation.
  */
-int MM_API mm_channel_event(channel* c, channel_value v);
+MM_API int mm_channel_event(channel* c, channel_value v);
 
 /*
  * Query all active instances for a given backend.
  * *i will need to be freed by the caller.
  */
-int MM_API mm_backend_instances(char* backend, size_t* n, instance*** i);
+MM_API int mm_backend_instances(char* backend, size_t* n, instance*** i);
 
 /*
  * Query an internal timestamp, which is updated every core iteration.
  * This timestamp should not be used as a performance counter, but can be
  * used for timeouting. Resolution is milliseconds.
  */
-uint64_t MM_API mm_timestamp();
+MM_API uint64_t mm_timestamp();
 
 /*
  * Create a channel-to-channel mapping. This API should not
-- 
cgit v1.2.3


From 49855046f683deb7fdadc2c3d8caf513099b4803 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Wed, 4 Sep 2019 20:26:24 +0200
Subject: Use platform-independent specifiers for printf calls

---
 TODO              |  5 ++++-
 backends/artnet.c |  8 ++++----
 backends/maweb.c  | 34 ++++++++++++++++++----------------
 backends/osc.c    | 24 ++++++++++++------------
 backends/sacn.c   | 10 +++++-----
 config.c          |  6 +++---
 midimonster.h     |  1 +
 portability.h     |  4 ++++
 8 files changed, 51 insertions(+), 41 deletions(-)

(limited to 'midimonster.h')

diff --git a/TODO b/TODO
index d04773b..cba1c15 100644
--- a/TODO
+++ b/TODO
@@ -1,10 +1,13 @@
+winmidi
+rename
+release
+
 MIDI NRPN
 keepalive channels per backend?
 mm_backend_start might get some arguments so they don't have to fetch them all the time
 mm_channel_resolver might get additional info about the mapping direction
 Note source in channel value struct
 Optimize core channel search (store backend offset)
-Printing backend / Verbose mode
 
 mm_managed_fd.impl is not freed currently
 
diff --git a/backends/artnet.c b/backends/artnet.c
index 8e47d4f..e01ac94 100644
--- a/backends/artnet.c
+++ b/backends/artnet.c
@@ -32,7 +32,7 @@ static int artnet_listener(char* host, char* port){
 		return -1;
 	}
 
-	fprintf(stderr, "ArtNet backend interface %lu bound to %s port %s\n", artnet_fds, host, port);
+	fprintf(stderr, "ArtNet backend interface %" PRIsize_t " bound to %s port %s\n", artnet_fds, host, port);
 	artnet_fd[artnet_fds].fd = fd;
 	artnet_fd[artnet_fds].output_instances = 0;
 	artnet_fd[artnet_fds].output_instance = NULL;
@@ -235,7 +235,7 @@ static int artnet_set(instance* inst, size_t num, channel** c, channel_value* v)
 	artnet_instance_data* data = (artnet_instance_data*) inst->impl;
 
 	if(!data->dest_len){
-		fprintf(stderr, "ArtNet instance %s not enabled for output (%lu channel events)\n", inst->name, num);
+		fprintf(stderr, "ArtNet instance %s not enabled for output (%" PRIsize_t " channel events)\n", inst->name, num);
 		return 0;
 	}
 
@@ -300,7 +300,7 @@ static inline int artnet_process_frame(instance* inst, artnet_pkt* frame){
 			}
 
 			if(!chan){
-				fprintf(stderr, "Active channel %lu on %s not known to core\n", p, inst->name);
+				fprintf(stderr, "Active channel %" PRIsize_t " on %s not known to core\n", p, inst->name);
 				return 1;
 			}
 
@@ -447,7 +447,7 @@ static int artnet_start(){
 		}
 	}
 
-	fprintf(stderr, "ArtNet backend registering %lu descriptors to core\n", artnet_fds);
+	fprintf(stderr, "ArtNet backend registering %" PRIsize_t " descriptors to core\n", artnet_fds);
 	for(u = 0; u < artnet_fds; u++){
 		if(mm_manage_fd(artnet_fd[u].fd, BACKEND_NAME, 1, (void*) u)){
 			goto bail;
diff --git a/backends/maweb.c b/backends/maweb.c
index 80ab579..8d39f00 100644
--- a/backends/maweb.c
+++ b/backends/maweb.c
@@ -5,6 +5,8 @@
 #include <openssl/md5.h>
 #endif
 
+#define DEBUG
+
 #include "libmmbackend.h"
 #include "maweb.h"
 
@@ -338,7 +340,7 @@ static int maweb_process_playback(instance* inst, int64_t page, maweb_channel_ty
 			//ignore unused buttons
 			return 0;
 		}
-		fprintf(stderr, "maweb missing exec block data on exec %ld.%d\n", page, ident.fields.index);
+		fprintf(stderr, "maweb missing exec block data on exec %" PRIu64 ".%d\n", page, ident.fields.index);
 		return 1;
 	}
 
@@ -367,7 +369,7 @@ static int maweb_process_playback(instance* inst, int64_t page, maweb_channel_ty
 			mm_channel_event(chan, evt);
 		}
 
-		DBGPF("maweb page %ld exec %d value %f running %lu\n", page, ident.fields.index, json_obj_double(payload + control, "v", 0.0), json_obj_int(payload, "isRun", 0));
+		DBGPF("maweb page %" PRIu64 " exec %d value %f running %" PRIu64 "\n", page, ident.fields.index, json_obj_double(payload + control, "v", 0.0), json_obj_int(payload, "isRun", 0));
 		ident.fields.index++;
 		block++;
 	}
@@ -420,7 +422,7 @@ static int maweb_process_playbacks(instance* inst, int64_t page, char* payload,
 		group++;
 	}
 	updates_inflight--;
-	DBGPF("maweb playback message processing done, %lu updates inflight\n", updates_inflight);
+	DBGPF("maweb playback message processing done, %" PRIu64 " updates inflight\n", updates_inflight);
 	return 0;
 }
 
@@ -433,7 +435,7 @@ static int maweb_request_playbacks(instance* inst){
 	size_t page_index = 0, view = 3, channel = 0, offsets[3], channel_offset, channels;
 
 	if(updates_inflight){
-		fprintf(stderr, "maweb skipping update request, %lu updates still inflight\n", updates_inflight);
+		fprintf(stderr, "maweb skipping update request, %" PRIu64 " updates still inflight\n", updates_inflight);
 		return 0;
 	}
 
@@ -476,7 +478,7 @@ static int maweb_request_playbacks(instance* inst){
 		else{
 			//for the ma, the view equals the exec type requested (we can query all button execs from button view, all fader execs from fader view)
 			view = (data->input_channel[channel].fields.index >= 100) ? 3 : 2;
-			snprintf(item_types, sizeof(item_types), "[%lu]", view);
+			snprintf(item_types, sizeof(item_types), "[%" PRIsize_t "]", view);
 			//this channel must be included, so it must be in range for the first startindex
 			snprintf(item_indices, sizeof(item_indices), "[%d]", (data->input_channel[channel].fields.index / 5) * 5);
 
@@ -487,7 +489,7 @@ static int maweb_request_playbacks(instance* inst){
 
 			channels = data->input_channel[channel + channel_offset - 1].fields.index - (data->input_channel[channel].fields.index / 5) * 5;
 
-			snprintf(item_counts, sizeof(item_indices), "[%lu]", ((channels / 5) * 5 + 5));
+			snprintf(item_counts, sizeof(item_indices), "[%" PRIsize_t "]", ((channels / 5) * 5 + 5));
 		}
 
 		//advance base channel
@@ -499,12 +501,12 @@ static int maweb_request_playbacks(instance* inst){
 				"\"requestType\":\"playbacks\","
 				"\"startIndex\":%s,"
 				"\"itemsCount\":%s,"
-				"\"pageIndex\":%lu,"
+				"\"pageIndex\":%" PRIsize_t ","
 				"\"itemsType\":%s,"
-				"\"view\":%lu,"
+				"\"view\":%" PRIsize_t ","
 				"\"execButtonViewMode\":2,"	//extended
 				"\"buttonsViewMode\":0,"	//get vfader for button execs
-				"\"session\":%lu"
+				"\"session\":%" PRIu64
 				"}",
 				item_indices,
 				item_counts,
@@ -546,16 +548,16 @@ static int maweb_handle_message(instance* inst, char* payload, size_t payload_le
 		}
 	}
 
-	DBGPF("maweb message (%lu): %s\n", payload_length, payload);
+	DBGPF("maweb message (%" PRIsize_t "): %s\n", payload_length, payload);
 	if(json_obj(payload, "session") == JSON_NUMBER){
 		data->session = json_obj_int(payload, "session", data->session);
-		fprintf(stderr, "maweb session id is now %ld\n", data->session);
+		fprintf(stderr, "maweb session id is now %" PRIu64 "\n", data->session);
 	}
 
 	if(json_obj_bool(payload, "forceLogin", 0)){
 		fprintf(stderr, "maweb sending user credentials\n");
 		snprintf(xmit_buffer, sizeof(xmit_buffer),
-				"{\"requestType\":\"login\",\"username\":\"%s\",\"password\":\"%s\",\"session\":%ld}",
+				"{\"requestType\":\"login\",\"username\":\"%s\",\"password\":\"%s\",\"session\":%" PRIu64 "}",
 				(data->peer_type == peer_dot2) ? "remote" : data->user, data->pass, data->session);
 		maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
 	}
@@ -787,7 +789,7 @@ static int maweb_set(instance* inst, size_t num, channel** c, channel_value* v){
 						"\"pageIndex\":%d,"
 						"\"faderValue\":%f,"
 						"\"type\":1,"
-						"\"session\":%ld"
+						"\"session\":%" PRIu64
 						"}", ident.fields.index, ident.fields.page, v[n].normalised, data->session);
 				maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
 				break;
@@ -803,7 +805,7 @@ static int maweb_set(instance* inst, size_t num, channel** c, channel_value* v){
 						"\"pressed\":%s,"
 						"\"released\":%s,"
 						"\"type\":0,"
-						"\"session\":%ld"
+						"\"session\":%" PRIu64
 						"}", ident.fields.index, ident.fields.page,
 						(data->peer_type == peer_dot2 && ident.fields.type == exec_upper) ? 0 : (ident.fields.type - exec_button),
 						(v[n].normalised > 0.9) ? "true" : "false",
@@ -844,7 +846,7 @@ static int maweb_keepalive(){
 	for(u = 0; u < n; u++){
 		data = (maweb_instance_data*) inst[u]->impl;
 		if(data->login){
-			snprintf(xmit_buffer, sizeof(xmit_buffer), "{\"session\":%ld}", data->session);
+			snprintf(xmit_buffer, sizeof(xmit_buffer), "{\"session\":%" PRIu64 "}", data->session);
 			maweb_send_frame(inst[u], ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
 		}
 	}
@@ -926,7 +928,7 @@ static int maweb_start(){
 		return 0;
 	}
 
-	fprintf(stderr, "maweb backend registering %lu descriptors to core\n", n);
+	fprintf(stderr, "maweb backend registering %" PRIsize_t " descriptors to core\n", n);
 
 	//initialize timeouts
 	last_keepalive = last_update = mm_timestamp();
diff --git a/backends/osc.c b/backends/osc.c
index beb5527..bffbba8 100644
--- a/backends/osc.c
+++ b/backends/osc.c
@@ -239,20 +239,20 @@ static int osc_path_validate(char* path, uint8_t allow_patterns){
 	for(u = 0; u < strlen(path); u++){
 		for(c = 0; c < sizeof(illegal_chars); c++){
 			if(path[u] == illegal_chars[c]){
-				fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %lu\n", path, illegal_chars[c], u);
+				fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %" PRIsize_t "\n", path, illegal_chars[c], u);
 				return 1;
 			}
 		}
 
 		if(!isgraph(path[u])){
-			fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %lu\n", path, pattern_chars[c], u);
+			fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %" PRIsize_t "\n", path, pattern_chars[c], u);
 			return 1;
 		}
 
 		if(!allow_patterns){
 			for(c = 0; c < sizeof(pattern_chars); c++){
 				if(path[u] == pattern_chars[c]){
-					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %lu\n", path, pattern_chars[c], u);
+					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %" PRIsize_t "\n", path, pattern_chars[c], u);
 					return 1;
 				}
 			}
@@ -261,14 +261,14 @@ static int osc_path_validate(char* path, uint8_t allow_patterns){
 		switch(path[u]){
 			case '{':
 				if(square_open || curly_open){
-					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %lu\n", path, pattern_chars[c], u);
+					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %" PRIsize_t "\n", path, pattern_chars[c], u);
 					return 1;
 				}
 				curly_open = 1;
 				break;
 			case '[':
 				if(square_open || curly_open){
-					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %lu\n", path, pattern_chars[c], u);
+					fprintf(stderr, "%s is not a valid OSC path: Illegal '%c' at %" PRIsize_t "\n", path, pattern_chars[c], u);
 					return 1;
 				}
 				square_open = 1;
@@ -477,14 +477,14 @@ static int osc_register_pattern(osc_instance_data* data, char* pattern_path, cha
 		//parse min/max values
 		token = strtok(NULL, " ");
 		if(!token){
-			fprintf(stderr, "Missing minimum specification for parameter %lu of OSC pattern %s\n", u, pattern_path);
+			fprintf(stderr, "Missing minimum specification for parameter %" PRIsize_t " of OSC pattern %s\n", u, pattern_path);
 			return 1;
 		}
 		data->pattern[pattern].min[u] = osc_parse_value_spec(format[u], token);
 
 		token = strtok(NULL, " ");
 		if(!token){
-			fprintf(stderr, "Missing maximum specification for parameter %lu of OSC pattern %s\n", u, pattern_path);
+			fprintf(stderr, "Missing maximum specification for parameter %" PRIsize_t " of OSC pattern %s\n", u, pattern_path);
 			return 1;
 		}
 		data->pattern[pattern].max[u] = osc_parse_value_spec(format[u], token);
@@ -686,7 +686,7 @@ static int osc_output_channel(instance* inst, size_t channel){
 
 		//write data
 		if(offset + osc_data_length(data->channel[channel].type[p]) >= sizeof(xmit_buf)){
-			fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s at parameter %lu\n", inst->name, data->channel[channel].path, p);
+			fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s at parameter %" PRIsize_t "\n", inst->name, data->channel[channel].path, p);
 			return 1;
 		}
 
@@ -717,7 +717,7 @@ static int osc_set(instance* inst, size_t num, channel** c, channel_value* v){
 
 	osc_instance_data* data = (osc_instance_data*) inst->impl;
 	if(!data->dest_len){
-		fprintf(stderr, "OSC instance %s does not have a destination, output is disabled (%lu channels)\n", inst->name, num);
+		fprintf(stderr, "OSC instance %s does not have a destination, output is disabled (%" PRIsize_t " channels)\n", inst->name, num);
 		return 0;
 	}
 
@@ -775,7 +775,7 @@ static int osc_process_packet(instance* inst, char* local_path, char* format, ui
 	channel* chan = NULL;
 
 	if(payload_len % 4){
-		fprintf(stderr, "Invalid OSC packet, data length %lu\n", payload_len);
+		fprintf(stderr, "Invalid OSC packet, data length %" PRIsize_t "\n", payload_len);
 		return 0;
 	}
 
@@ -784,7 +784,7 @@ static int osc_process_packet(instance* inst, char* local_path, char* format, ui
 			ident.fields.channel = c;
 			//unconfigured input should work without errors (using default limits)
 			if(data->channel[c].params && strlen(format) != data->channel[c].params){
-				fprintf(stderr, "OSC message %s.%s had format %s, internal representation has %lu parameters\n", inst->name, local_path, format, data->channel[c].params);
+				fprintf(stderr, "OSC message %s.%s had format %s, internal representation has %" PRIsize_t " parameters\n", inst->name, local_path, format, data->channel[c].params);
 				continue;
 			}
 
@@ -925,7 +925,7 @@ static int osc_start(){
 		}
 	}
 
-	fprintf(stderr, "OSC backend registered %lu descriptors to core\n", fds);
+	fprintf(stderr, "OSC backend registered %" PRIsize_t " descriptors to core\n", fds);
 
 	free(inst);
 	return 0;
diff --git a/backends/sacn.c b/backends/sacn.c
index 470e3bd..6e1b20b 100644
--- a/backends/sacn.c
+++ b/backends/sacn.c
@@ -78,7 +78,7 @@ static int sacn_listener(char* host, char* port, uint8_t fd_flags){
 		return -1;
 	}
 
-	fprintf(stderr, "sACN backend interface %lu bound to %s port %s\n", global_cfg.fds, host, port);
+	fprintf(stderr, "sACN backend interface %" PRIsize_t " bound to %s port %s\n", global_cfg.fds, host, port);
 	global_cfg.fd[global_cfg.fds].fd = fd;
 	global_cfg.fd[global_cfg.fds].flags = fd_flags;
 	global_cfg.fd[global_cfg.fds].universes = 0;
@@ -300,7 +300,7 @@ static int sacn_set(instance* inst, size_t num, channel** c, channel_value* v){
 	}
 
 	if(!data->xmit_prio){
-		fprintf(stderr, "sACN instance %s not enabled for output (%lu channel events)\n", inst->name, num);
+		fprintf(stderr, "sACN instance %s not enabled for output (%" PRIsize_t " channel events)\n", inst->name, num);
 		return 0;
 	}
 
@@ -385,7 +385,7 @@ static int sacn_process_frame(instance* inst, sacn_frame_root* frame, sacn_frame
 			}
 
 			if(!chan){
-				fprintf(stderr, "Active channel %lu on %s not known to core", u, inst->name);
+				fprintf(stderr, "Active channel %" PRIsize_t " on %s not known to core", u, inst->name);
 				return 1;
 			}
 
@@ -453,7 +453,7 @@ static void sacn_discovery(size_t fd){
 		memcpy(pdu.data.data, global_cfg.fd[fd].universe + page * 512, universes * sizeof(uint16_t));
 
 		if(sendto(global_cfg.fd[fd].fd, (uint8_t*) &pdu, sizeof(pdu) - (512 - universes) * sizeof(uint16_t), 0, (struct sockaddr*) &discovery_dest, sizeof(discovery_dest)) < 0){
-			fprintf(stderr, "Failed to output sACN universe discovery frame for interface %lu: %s\n", fd, strerror(errno));
+			fprintf(stderr, "Failed to output sACN universe discovery frame for interface %" PRIsize_t ": %s\n", fd, strerror(errno));
 		}
 	}
 }
@@ -615,7 +615,7 @@ static int sacn_start(){
 		}
 	}
 
-	fprintf(stderr, "sACN backend registering %lu descriptors to core\n", global_cfg.fds);
+	fprintf(stderr, "sACN backend registering %" PRIsize_t " descriptors to core\n", global_cfg.fds);
 	for(u = 0; u < global_cfg.fds; u++){
 		//allocate memory for storing last frame transmission timestamp
 		global_cfg.fd[u].last_frame = calloc(global_cfg.fd[u].universes, sizeof(uint64_t));
diff --git a/config.c b/config.c
index 93fb56d..f4d928e 100644
--- a/config.c
+++ b/config.c
@@ -162,7 +162,7 @@ static int config_glob_scan(instance* inst, channel_spec* spec){
 	}
 	if(!spec->internal){
 		//TODO try to parse globs externally
-		fprintf(stderr, "Failed to parse glob %lu in %s internally\n", u + 1, spec->spec);
+		fprintf(stderr, "Failed to parse glob %" PRIsize_t " in %s internally\n", u + 1, spec->spec);
 		return 1;
 	}
 
@@ -199,7 +199,7 @@ static channel* config_glob_resolve(instance* inst, channel_spec* spec, uint64_t
 		//write out value
 		bytes = snprintf(resolved_spec + spec->glob[glob - 1].offset[0],
 				glob_length,
-				"%lu",
+				"%" PRIu64,
 				current_value);
 		if(bytes > glob_length){
 			fprintf(stderr, "Internal error resolving glob %s\n", spec->spec);
@@ -279,7 +279,7 @@ static int config_map(char* to_raw, char* from_raw){
 	if((spec_to.channels != spec_from.channels && spec_from.channels != 1 && spec_to.channels != 1)
 			|| spec_to.channels == 0
 			|| spec_from.channels == 0){
-		fprintf(stderr, "Multi-channel specification size mismatch: %s.%s (%lu channels) - %s.%s (%lu channels)\n",
+		fprintf(stderr, "Multi-channel specification size mismatch: %s.%s (%" PRIsize_t " channels) - %s.%s (%" PRIsize_t " channels)\n",
 				instance_from->name,
 				spec_from.spec,
 				spec_from.channels,
diff --git a/midimonster.h b/midimonster.h
index 270a61f..491cc11 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
+#include <inttypes.h>
 
 #ifndef MM_API
 	#ifdef _WIN32
diff --git a/portability.h b/portability.h
index 903ecd8..f0bfd07 100644
--- a/portability.h
+++ b/portability.h
@@ -35,4 +35,8 @@
 	#define htole64(x) (x)
 	#define be64toh(x) _byteswap_uint64(x)
 	#define le64toh(x) (x)
+
+	#define PRIsize_t "Iu"
+#else
+	#define PRIsize_t "zu"
 #endif
-- 
cgit v1.2.3


From 350f0d2d2eaff5f0d57b09857102e2df1e96d733 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Thu, 7 Nov 2019 18:44:19 +0100
Subject: Makefile install target and packaging instructions (Fixes #28)

---
 Makefile                  | 22 +++++++++++++++++-----
 README.md                 | 23 +++++++++++++++++++++++
 backends/lua.md           |  5 +----
 backends/maweb.c          |  2 +-
 backends/winmidi.c        |  2 +-
 config.c                  | 38 +++++++++++++++++++++++++++++++++++---
 configs/flying-faders.cfg |  2 +-
 configs/lua.cfg           |  2 +-
 midimonster.h             | 13 ++++++++++++-
 plugin.c                  | 12 ++++++++++--
 10 files changed, 102 insertions(+), 19 deletions(-)

(limited to 'midimonster.h')

diff --git a/Makefile b/Makefile
index 2d88c49..5a83a2d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,7 @@
-.PHONY: all clean run sanitize backends windows full backends-full
+.PHONY: all clean run sanitize backends windows full backends-full install
 OBJS = config.o backend.o plugin.o
-PLUGINDIR = "\"./backends/\""
-PLUGINDIR_W32 = "\"backends\\\\\""
 
+PREFIX ?= /usr
 SYSTEM := $(shell uname -s)
 
 CFLAGS ?= -g -Wall -Wpedantic
@@ -11,7 +10,6 @@ CFLAGS += -fvisibility=hidden
 
 #CFLAGS += -DDEBUG
 midimonster: LDLIBS = -ldl
-midimonster: CFLAGS += -DPLUGINS=$(PLUGINDIR)
 
 # Work around strange linker passing convention differences in Linux and OSX
 ifeq ($(SYSTEM),Linux)
@@ -21,6 +19,14 @@ ifeq ($(SYSTEM),Darwin)
 midimonster: LDFLAGS += -Wl,-export_dynamic
 endif
 
+# Allow overriding the locations for backend plugins and default configuration
+ifdef DEFAULT_CFG
+midimonster: CFLAGS += -DDEFAULT_CFG=\"$(DEFAULT_CFG)\"
+endif
+ifdef PLUGINS
+midimonster: CFLAGS += -DPLUGINS=\"$(PLUGINS)\"
+endif
+
 all: midimonster backends
 
 full: midimonster backends-full
@@ -39,7 +45,7 @@ midimonster: midimonster.c portability.h $(OBJS)
 	$(CC) $(CFLAGS) $(LDFLAGS) $< $(OBJS) $(LDLIBS) -o $@
 
 midimonster.exe: export CC = x86_64-w64-mingw32-gcc
-midimonster.exe: CFLAGS += -DPLUGINS=$(PLUGINDIR_W32) -Wno-format
+midimonster.exe: CFLAGS += -Wno-format
 midimonster.exe: LDLIBS = -lws2_32
 midimonster.exe: LDFLAGS += -Wl,--out-implib,libmmapi.a
 midimonster.exe: midimonster.c portability.h $(OBJS)
@@ -55,6 +61,12 @@ clean:
 run:
 	valgrind --leak-check=full --show-leak-kinds=all ./midimonster
 
+install:
+		install -d "$(DESTDIR)$(PREFIX)/bin"
+		install -d "$(DESTDIR)$(PREFIX)/lib/midimonster"
+		install -m 0755 midimonster "$(DESTDIR)$(PREFIX)/bin"
+		install -m 0755 backends/*.so "$(DESTDIR)$(PREFIX)/lib/midimonster"
+
 sanitize: export CC = clang
 sanitize: export CFLAGS += -g -Wall -Wpedantic -fsanitize=address -fsanitize=undefined -fno-omit-frame-pointer
 sanitize: midimonster backends
diff --git a/README.md b/README.md
index 130945a..c31f16c 100644
--- a/README.md
+++ b/README.md
@@ -156,6 +156,16 @@ be used to build a subset of the backends as well as the core.
 
 For Linux and OSX, just running `make` in the source directory should do the trick.
 
+The build process accepts the following parameters, either from the environment or
+as arguments to the `make` invocation:
+
+| Target	| Parameter		| Default value			| Description			|
+|---------------|-----------------------|-------------------------------|-------------------------------|
+| build targets	| `DEFAULT_CFG`		| `monster.cfg`			| Default configuration file	|
+| build targets	| `PLUGINS`		| Linux/OSX: `./backends/`, Windows: `backends\` | Backend plugin library path	|
+| `install`	| `DESTDIR`		| empty				| Destination directory for packaging builds	|
+| `install`	| `PREFIX`		| `/usr`			| Install prefix for binaries	|
+
 Some backends have been marked as optional as they require rather large additional software to be installed,
 for example the `ola` backend. To create a build including these, run `make full`.
 
@@ -163,6 +173,19 @@ To build for Windows, you still need to compile on a Linux machine.
 Install the crosscompiler package listed above and run `make windows`.
 This will build `midimonster.exe` as well as a set of backends as DLL files.
 
+For system-wide install or packaging builds, the following steps are recommended:
+
+```
+export PREFIX=/usr
+export PLUGINS=$PREFIX/lib/midimonster
+export DEFAULT_CFG=/etc/midimonster.cfg
+make
+make install
+```
+
+Depending on your configuration of `DESTDIR`, the `make install` step may require root privileges to
+install the binaries to the appropriate destinations.
+
 ## Development
 
 The architecture is split into the `midimonster` core, handling mapping
diff --git a/backends/lua.md b/backends/lua.md
index 6ad5c2a..f38e189 100644
--- a/backends/lua.md
+++ b/backends/lua.md
@@ -43,7 +43,7 @@ The `lua` backend does not take any global configuration.
 
 | Option	| Example value		| Default value 	| Description		|
 |---------------|-----------------------|-----------------------|-----------------------|
-| `script`	| `script.lua`		| none			| Lua source file	|
+| `script`	| `script.lua`		| none			| Lua source file (relative to configuration file)|
 
 A single instance may have multiple `source` options specified, which will all be read cumulatively.
 
@@ -64,6 +64,3 @@ Using these names as arguments to the output and value interface functions works
 
 Output values will not trigger corresponding input event handlers unless the channel is mapped
 back in the MIDIMonster configuration.
-
-The path to the Lua source files is relative to the current working directory. This may lead
-to problems when copying configuration between installations.
diff --git a/backends/maweb.c b/backends/maweb.c
index c98d04b..57d04ae 100644
--- a/backends/maweb.c
+++ b/backends/maweb.c
@@ -470,7 +470,7 @@ static int maweb_request_playbacks(instance* inst){
 		offsets[0] = offsets[1] = offsets[2] = 1;
 		page_index = data->channel[channel].page;
 		//poll logic differs between the consoles because reasons
-		//dont quote me on this section
+		//don't quote me on this section
 		if(data->peer_type == peer_dot2){
 			//blocks 0, 100 & 200 have 21 execs and need to be queried from fader view
 			view = (data->channel[channel].index >= 300) ? 3 : 2;
diff --git a/backends/winmidi.c b/backends/winmidi.c
index de7d867..d6bc0bc 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -84,7 +84,7 @@ static int winmidi_configure_instance(instance* inst, char* option, char* value)
 	}
 	if(!strcmp(option, "write")){
 		if(data->write){
-			fprintf(stderr, "winmidi instance %s already connected to an otput device\n", inst->name);
+			fprintf(stderr, "winmidi instance %s already connected to an output device\n", inst->name);
 			return 1;
 		}
 		data->write = strdup(value);
diff --git a/config.c b/config.c
index f4d928e..ddee720 100644
--- a/config.c
+++ b/config.c
@@ -1,5 +1,7 @@
 #include <string.h>
 #include <ctype.h>
+#include <unistd.h>
+#include <errno.h>
 #include "midimonster.h"
 #include "config.h"
 #include "backend.h"
@@ -310,16 +312,45 @@ done:
 	return rv;
 }
 
-int config_read(char* cfg_file){
+int config_read(char* cfg_filepath){
 	int rv = 1;
 	size_t line_alloc = 0;
 	ssize_t status;
 	map_type mapping_type = map_rtl;
 	char* line_raw = NULL, *line, *separator;
-	FILE* source = fopen(cfg_file, "r");
+
+	//create heap copy of file name because original might be in readonly memory
+	char* source_dir = strdup(cfg_filepath), *source_file = NULL;
+	#ifdef _WIN32
+	char path_separator = '\\';
+	#else
+	char path_separator = '/';
+	#endif
+
+	if(!source_dir){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return 1;
+	}
+
+	//change working directory to the one containing the configuration file so relative paths work as expected
+	source_file = strrchr(source_dir, path_separator);
+	if(source_file){
+		*source_file = 0;
+		source_file++;
+		if(chdir(source_dir)){
+			fprintf(stderr, "Failed to change to configuration file directory %s: %s\n", source_dir, strerror(errno));
+			goto bail;
+		}
+	}
+	else{
+		source_file = source_dir;
+	}
+
+	FILE* source = fopen(source_file, "r");
+
 	if(!source){
 		fprintf(stderr, "Failed to open configuration file for reading\n");
-		return 1;
+		goto bail;
 	}
 
 	for(status = getline(&line_raw, &line_alloc, source); status >= 0; status = getline(&line_raw, &line_alloc, source)){
@@ -459,6 +490,7 @@ int config_read(char* cfg_file){
 
 	rv = 0;
 bail:
+	free(source_dir);
 	fclose(source);
 	free(line_raw);
 	return rv;
diff --git a/configs/flying-faders.cfg b/configs/flying-faders.cfg
index 4197581..d331f38 100644
--- a/configs/flying-faders.cfg
+++ b/configs/flying-faders.cfg
@@ -13,7 +13,7 @@ dest = learn@9000
 /1/xy = ff 0.0 1.0 0.0 1.0
 
 [lua generator]
-script = configs/flying-faders.lua
+script = flying-faders.lua
 
 [map]
 
diff --git a/configs/lua.cfg b/configs/lua.cfg
index af17496..098c0f1 100644
--- a/configs/lua.cfg
+++ b/configs/lua.cfg
@@ -13,7 +13,7 @@ axis.ABS_X = 34300 0 65535 255 4095
 axis.ABS_Y = 34300 0 65535 255 4095
 
 [lua lua]
-script = configs/demo.lua
+script = demo.lua
 
 [artnet art]
 universe = 0
diff --git a/midimonster.h b/midimonster.h
index 491cc11..b05326c 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -33,7 +33,18 @@
 #include "portability.h"
 
 /* Default configuration file name to read when no other is specified */
-#define DEFAULT_CFG "monster.cfg"
+#ifndef DEFAULT_CFG
+	#define DEFAULT_CFG "monster.cfg"
+#endif
+
+/* Default backend plugin location */
+#ifndef PLUGINS
+	#ifndef _WIN32
+		#define PLUGINS "./backends/"
+	#else
+		#define PLUGINS "backends\\"
+	#endif
+#endif
 
 /* Forward declare some of the structs so we can use them in each other */
 struct _channel_value;
diff --git a/plugin.c b/plugin.c
index dd99041..a14baff 100644
--- a/plugin.c
+++ b/plugin.c
@@ -24,13 +24,21 @@ static int plugin_attach(char* path, char* file){
 	plugin_init init = NULL;
 	void* handle = NULL;
 	char* lib = NULL;
+	#ifdef _WIN32
+	char* path_separator = "\\";
+	#else
+	char* path_separator = "/";
+	#endif
 
-	lib = calloc(strlen(path) + strlen(file) + 1, sizeof(char));
+	lib = calloc(strlen(path) + strlen(file) + 2, sizeof(char));
 	if(!lib){
 		fprintf(stderr, "Failed to allocate memory\n");
 		return 1;
 	}
-	snprintf(lib, strlen(path) + strlen(file) + 1, "%s%s", path, file);
+	snprintf(lib, strlen(path) + strlen(file) + 2, "%s%s%s",
+			path,
+			(path[strlen(path)] == path_separator[0]) ? "" : path_separator,
+			file);
 
 	handle = dlopen(lib, RTLD_NOW);
 	if(!handle){
-- 
cgit v1.2.3


From a0831a2b970404eaa9b80ff97ab46ee759131414 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Tue, 3 Dec 2019 22:37:45 +0100
Subject: Add error checking for shell callouts during build

---
 backends/Makefile | 8 ++++----
 midimonster.c     | 2 +-
 midimonster.h     | 5 +++++
 3 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'midimonster.h')

diff --git a/backends/Makefile b/backends/Makefile
index 901ec49..4e37ca4 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -43,12 +43,12 @@ winmidi.dll: LDLIBS += -lwinmm -lws2_32
 
 jack.so: LDLIBS = -ljack -lpthread
 midi.so: LDLIBS = -lasound
-evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev)
-evdev.so: LDLIBS = $(shell pkg-config --libs libevdev)
+evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev || echo "-DBUILD_ERROR=\"Missing pkg-config data for libevdev\"")
+evdev.so: LDLIBS = $(shell pkg-config --libs libevdev || echo "-DBUILD_ERROR=\"Missing pkg-config data for libevdev\"")
 ola.so: LDLIBS = -lola
 ola.so: CPPFLAGS += -Wno-write-strings
-lua.so: CFLAGS += $(shell pkg-config --cflags lua5.3)
-lua.so: LDLIBS += $(shell pkg-config --libs lua5.3)
+lua.so: CFLAGS += $(shell pkg-config --cflags lua53 || echo "-DBUILD_ERROR=\"Missing pkg-config data for lua53\"")
+lua.so: LDLIBS += $(shell pkg-config --libs lua53 || echo "-DBUILD_ERROR=\"Missing pkg-config data for lua53\"")
 
 %.so :: %.c %.h $(BACKEND_LIB)
 	$(CC) $(CFLAGS) $(LDLIBS) $< $(ADDITIONAL_OBJS) -o $@ $(LDFLAGS)
diff --git a/midimonster.c b/midimonster.c
index 25cf4a0..eb64974 100644
--- a/midimonster.c
+++ b/midimonster.c
@@ -224,7 +224,7 @@ static void event_free(){
 }
 
 static int usage(char* fn){
-	fprintf(stderr, "MIDIMonster v0.1\n");
+	fprintf(stderr, "MIDIMonster v0.2\n");
 	fprintf(stderr, "Usage:\n");
 	fprintf(stderr, "\t%s <configfile>\n", fn);
 	return EXIT_FAILURE;
diff --git a/midimonster.h b/midimonster.h
index b05326c..3922b03 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -29,6 +29,11 @@
 	#define DBG(message)
 #endif
 
+/* Stop compilation if the build system reports an error */
+#ifdef BUILD_ERROR
+	#error The build system reported an error, compilation stopped. Refer to the invocation for this compilation unit for more information.
+#endif
+
 /* Pull in additional defines for non-linux platforms */
 #include "portability.h"
 
-- 
cgit v1.2.3


From 1107a91861189d28d771d02d721d61b403aac38a Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Wed, 4 Dec 2019 01:21:14 +0100
Subject: Explicitly mark the backend init symbol visible

---
 backends/artnet.c   |  2 +-
 backends/artnet.h   |  2 +-
 backends/evdev.c    |  2 +-
 backends/evdev.h    |  2 +-
 backends/jack.c     |  4 +++-
 backends/jack.h     |  2 +-
 backends/loopback.c |  2 +-
 backends/loopback.h |  2 +-
 backends/lua.c      |  2 +-
 backends/lua.h      |  2 +-
 backends/maweb.c    |  2 +-
 backends/maweb.h    |  2 +-
 backends/midi.c     |  2 +-
 backends/midi.h     |  2 +-
 backends/ola.cpp    |  2 +-
 backends/ola.h      |  2 +-
 backends/osc.c      |  2 +-
 backends/osc.h      |  2 +-
 backends/sacn.c     |  2 +-
 backends/sacn.h     |  2 +-
 backends/winmidi.c  |  2 +-
 backends/winmidi.h  |  2 +-
 midimonster.h       | 10 ++++++++++
 23 files changed, 34 insertions(+), 22 deletions(-)

(limited to 'midimonster.h')

diff --git a/backends/artnet.c b/backends/artnet.c
index e01ac94..8a62a43 100644
--- a/backends/artnet.c
+++ b/backends/artnet.c
@@ -41,7 +41,7 @@ static int artnet_listener(char* host, char* port){
 	return 0;
 }
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend artnet = {
 		.name = BACKEND_NAME,
 		.conf = artnet_configure,
diff --git a/backends/artnet.h b/backends/artnet.h
index f5aa745..cce11d1 100644
--- a/backends/artnet.h
+++ b/backends/artnet.h
@@ -3,7 +3,7 @@
 #endif
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int artnet_configure(char* option, char* value);
 static int artnet_configure_instance(instance* instance, char* option, char* value);
 static instance* artnet_instance();
diff --git a/backends/evdev.c b/backends/evdev.c
index b19cda8..dd2231b 100644
--- a/backends/evdev.c
+++ b/backends/evdev.c
@@ -24,7 +24,7 @@ static struct {
 	.detect = 0
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend evdev = {
 		.name = BACKEND_NAME,
 		.conf = evdev_configure,
diff --git a/backends/evdev.h b/backends/evdev.h
index 48bd0ab..30ce892 100644
--- a/backends/evdev.h
+++ b/backends/evdev.h
@@ -8,7 +8,7 @@
  * disabled by building with -DEVDEV_NO_UINPUT
  */
 
-int init();
+MM_PLUGIN_API int init();
 static int evdev_configure(char* option, char* value);
 static int evdev_configure_instance(instance* instance, char* option, char* value);
 static instance* evdev_instance();
diff --git a/backends/jack.c b/backends/jack.c
index b3aacd4..e8a63bc 100644
--- a/backends/jack.c
+++ b/backends/jack.c
@@ -4,6 +4,8 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
+#define DEBUG
+
 #include "jack.h"
 #include <jack/midiport.h>
 #include <jack/metadata.h>
@@ -27,7 +29,7 @@ static struct /*_mmjack_backend_cfg*/ {
 	.jack_shutdown = 0
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend mmjack = {
 		.name = BACKEND_NAME,
 		.conf = mmjack_configure,
diff --git a/backends/jack.h b/backends/jack.h
index dd59cd2..5598042 100644
--- a/backends/jack.h
+++ b/backends/jack.h
@@ -2,7 +2,7 @@
 #include <jack/jack.h>
 #include <pthread.h>
 
-int init();
+MM_PLUGIN_API int init();
 static int mmjack_configure(char* option, char* value);
 static int mmjack_configure_instance(instance* inst, char* option, char* value);
 static instance* mmjack_instance();
diff --git a/backends/loopback.c b/backends/loopback.c
index 083a312..0a45bde 100644
--- a/backends/loopback.c
+++ b/backends/loopback.c
@@ -3,7 +3,7 @@
 
 #define BACKEND_NAME "loopback"
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend loopback = {
 		.name = BACKEND_NAME,
 		.conf = loopback_configure,
diff --git a/backends/loopback.h b/backends/loopback.h
index c73ca20..a08417b 100644
--- a/backends/loopback.h
+++ b/backends/loopback.h
@@ -1,6 +1,6 @@
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int loopback_configure(char* option, char* value);
 static int loopback_configure_instance(instance* inst, char* option, char* value);
 static instance* loopback_instance();
diff --git a/backends/lua.c b/backends/lua.c
index 3555e72..0b47b2c 100644
--- a/backends/lua.c
+++ b/backends/lua.c
@@ -19,7 +19,7 @@ static int timer_fd = -1;
 static uint64_t last_timestamp;
 #endif
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend lua = {
 		#ifndef MMBACKEND_LUA_TIMERFD
 		.interval = lua_interval,
diff --git a/backends/lua.h b/backends/lua.h
index f2583a8..e187a8e 100644
--- a/backends/lua.h
+++ b/backends/lua.h
@@ -9,7 +9,7 @@
 	#define MMBACKEND_LUA_TIMERFD
 #endif
 
-int init();
+MM_PLUGIN_API int init();
 static int lua_configure(char* option, char* value);
 static int lua_configure_instance(instance* inst, char* option, char* value);
 static instance* lua_instance();
diff --git a/backends/maweb.c b/backends/maweb.c
index c495512..08156f2 100644
--- a/backends/maweb.c
+++ b/backends/maweb.c
@@ -72,7 +72,7 @@ static maweb_command_key cmdline_keys[] = {
 	{"GO_MINUS_SMALL", 50}, {"PAUSE_SMALL", 51}, {"GO_PLUS_SMALL", 52}
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend maweb = {
 		.name = BACKEND_NAME,
 		.conf = maweb_configure,
diff --git a/backends/maweb.h b/backends/maweb.h
index 14e4755..9091cda 100644
--- a/backends/maweb.h
+++ b/backends/maweb.h
@@ -1,6 +1,6 @@
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int maweb_configure(char* option, char* value);
 static int maweb_configure_instance(instance* inst, char* option, char* value);
 static instance* maweb_instance();
diff --git a/backends/midi.c b/backends/midi.c
index cde278b..f380f59 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -23,7 +23,7 @@ static struct {
 	.detect = 0
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend midi = {
 		.name = BACKEND_NAME,
 		.conf = midi_configure,
diff --git a/backends/midi.h b/backends/midi.h
index 6c3fcf9..b9934f1 100644
--- a/backends/midi.h
+++ b/backends/midi.h
@@ -1,6 +1,6 @@
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int midi_configure(char* option, char* value);
 static int midi_configure_instance(instance* instance, char* option, char* value);
 static instance* midi_instance();
diff --git a/backends/ola.cpp b/backends/ola.cpp
index 632cef7..d069a8c 100644
--- a/backends/ola.cpp
+++ b/backends/ola.cpp
@@ -11,7 +11,7 @@
 static ola::io::SelectServer* ola_select = NULL;
 static ola::OlaCallbackClient* ola_client = NULL;
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend ola = {
 		.name = BACKEND_NAME,
 		.conf = ola_configure,
diff --git a/backends/ola.h b/backends/ola.h
index c943d52..1637495 100644
--- a/backends/ola.h
+++ b/backends/ola.h
@@ -4,7 +4,7 @@ extern "C" {
 	#undef min
 	#undef max
 
-	int init();
+	MM_PLUGIN_API int init();
 	static int ola_configure(char* option, char* value);
 	static int ola_configure_instance(instance* instance, char* option, char* value);
 	static instance* ola_instance();
diff --git a/backends/osc.c b/backends/osc.c
index bffbba8..d9f9139 100644
--- a/backends/osc.c
+++ b/backends/osc.c
@@ -19,7 +19,7 @@ static struct {
 	.detect = 0
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend osc = {
 		.name = BACKEND_NAME,
 		.conf = osc_configure,
diff --git a/backends/osc.h b/backends/osc.h
index dd5afb0..86be285 100644
--- a/backends/osc.h
+++ b/backends/osc.h
@@ -7,7 +7,7 @@
 #define OSC_RECV_BUF 8192
 #define OSC_XMIT_BUF 8192
 
-int init();
+MM_PLUGIN_API int init();
 static int osc_configure(char* option, char* value);
 static int osc_configure_instance(instance* inst, char* option, char* value);
 static instance* osc_instance();
diff --git a/backends/sacn.c b/backends/sacn.c
index 6e1b20b..d8b3eb3 100644
--- a/backends/sacn.c
+++ b/backends/sacn.c
@@ -31,7 +31,7 @@ static struct /*_sacn_global_config*/ {
 	.last_announce = 0
 };
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend sacn = {
 		.name = BACKEND_NAME,
 		.conf = sacn_configure,
diff --git a/backends/sacn.h b/backends/sacn.h
index 7af2a36..631d3a4 100644
--- a/backends/sacn.h
+++ b/backends/sacn.h
@@ -1,6 +1,6 @@
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int sacn_configure(char* option, char* value);
 static int sacn_configure_instance(instance* instance, char* option, char* value);
 static instance* sacn_instance();
diff --git a/backends/winmidi.c b/backends/winmidi.c
index ffca3b4..bda5401 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -23,7 +23,7 @@ static struct {
 
 //TODO receive feedback socket until EAGAIN
 
-int init(){
+MM_PLUGIN_API int init(){
 	backend winmidi = {
 		.name = BACKEND_NAME,
 		.conf = winmidi_configure,
diff --git a/backends/winmidi.h b/backends/winmidi.h
index e4abda1..ffa6a26 100644
--- a/backends/winmidi.h
+++ b/backends/winmidi.h
@@ -1,6 +1,6 @@
 #include "midimonster.h"
 
-int init();
+MM_PLUGIN_API int init();
 static int winmidi_configure(char* option, char* value);
 static int winmidi_configure_instance(instance* inst, char* option, char* value);
 static instance* winmidi_instance();
diff --git a/midimonster.h b/midimonster.h
index 3922b03..1192d6a 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -5,6 +5,7 @@
 #include <stdint.h>
 #include <inttypes.h>
 
+/* API call attributes and visibilities */
 #ifndef MM_API
 	#ifdef _WIN32
 		#define MM_API __attribute__((dllimport))
@@ -13,6 +14,15 @@
 	#endif
 #endif
 
+/* Some build systems may apply the -fvisibility=hidden parameter from the core build to the backends, so mark the init function visible */
+#ifndef MM_PLUGIN_API
+	#ifdef _WIN32
+		#define MM_PLUGIN_API __attribute__((dllexport))
+	#else
+		#define MM_PLUGIN_API __attribute__((visibility ("default")))
+	#endif
+#endif
+
 /* Straight-forward min / max macros */
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #define min(a,b) (((a) < (b)) ? (a) : (b))
-- 
cgit v1.2.3


From 3eada28582b144519e95a44ee3adc3f46d39036e Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Thu, 5 Dec 2019 21:05:14 +0100
Subject: Add flags parameter to channel parser plugin API (Fixes #31)

---
 backends/artnet.c   |  2 +-
 backends/artnet.h   |  2 +-
 backends/evdev.c    |  2 +-
 backends/evdev.h    |  2 +-
 backends/jack.c     |  2 +-
 backends/jack.h     |  2 +-
 backends/loopback.c |  2 +-
 backends/loopback.h |  2 +-
 backends/lua.c      |  2 +-
 backends/lua.h      |  2 +-
 backends/maweb.c    |  2 +-
 backends/maweb.h    |  2 +-
 backends/midi.c     |  2 +-
 backends/midi.h     |  2 +-
 backends/ola.cpp    |  2 +-
 backends/ola.h      |  2 +-
 backends/osc.c      |  2 +-
 backends/osc.h      |  2 +-
 backends/sacn.c     |  2 +-
 backends/sacn.h     |  2 +-
 backends/winmidi.c  |  2 +-
 backends/winmidi.h  |  2 +-
 config.c            |  8 ++++----
 midimonster.h       | 15 ++++++++++++---
 24 files changed, 38 insertions(+), 29 deletions(-)

(limited to 'midimonster.h')

diff --git a/backends/artnet.c b/backends/artnet.c
index 8a62a43..57eb7b1 100644
--- a/backends/artnet.c
+++ b/backends/artnet.c
@@ -156,7 +156,7 @@ static int artnet_configure_instance(instance* inst, char* option, char* value){
 	return 1;
 }
 
-static channel* artnet_channel(instance* inst, char* spec){
+static channel* artnet_channel(instance* inst, char* spec, uint8_t flags){
 	artnet_instance_data* data = (artnet_instance_data*) inst->impl;
 	char* spec_next = spec;
 	unsigned chan_a = strtoul(spec, &spec_next, 10);
diff --git a/backends/artnet.h b/backends/artnet.h
index cce11d1..f6a6709 100644
--- a/backends/artnet.h
+++ b/backends/artnet.h
@@ -7,7 +7,7 @@ MM_PLUGIN_API int init();
 static int artnet_configure(char* option, char* value);
 static int artnet_configure_instance(instance* instance, char* option, char* value);
 static instance* artnet_instance();
-static channel* artnet_channel(instance* instance, char* spec);
+static channel* artnet_channel(instance* instance, char* spec, uint8_t flags);
 static int artnet_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int artnet_handle(size_t num, managed_fd* fds);
 static int artnet_start();
diff --git a/backends/evdev.c b/backends/evdev.c
index dd2231b..0da5ae6 100644
--- a/backends/evdev.c
+++ b/backends/evdev.c
@@ -249,7 +249,7 @@ static int evdev_configure_instance(instance* inst, char* option, char* value) {
 	return 1;
 }
 
-static channel* evdev_channel(instance* inst, char* spec){
+static channel* evdev_channel(instance* inst, char* spec, uint8_t flags){
 #ifndef EVDEV_NO_UINPUT
 	evdev_instance_data* data = (evdev_instance_data*) inst->impl;
 #endif
diff --git a/backends/evdev.h b/backends/evdev.h
index 30ce892..6504416 100644
--- a/backends/evdev.h
+++ b/backends/evdev.h
@@ -12,7 +12,7 @@ MM_PLUGIN_API int init();
 static int evdev_configure(char* option, char* value);
 static int evdev_configure_instance(instance* instance, char* option, char* value);
 static instance* evdev_instance();
-static channel* evdev_channel(instance* instance, char* spec);
+static channel* evdev_channel(instance* instance, char* spec, uint8_t flags);
 static int evdev_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int evdev_handle(size_t num, managed_fd* fds);
 static int evdev_start();
diff --git a/backends/jack.c b/backends/jack.c
index 926f800..e7bed04 100644
--- a/backends/jack.c
+++ b/backends/jack.c
@@ -409,7 +409,7 @@ static int mmjack_parse_midispec(mmjack_channel_ident* ident, char* spec){
 	return 0;
 }
 
-static channel* mmjack_channel(instance* inst, char* spec){
+static channel* mmjack_channel(instance* inst, char* spec, uint8_t flags){
 	mmjack_instance_data* data = (mmjack_instance_data*) inst->impl;
 	mmjack_channel_ident ident = {
 		.label = 0
diff --git a/backends/jack.h b/backends/jack.h
index 5598042..a7f3e8b 100644
--- a/backends/jack.h
+++ b/backends/jack.h
@@ -6,7 +6,7 @@ MM_PLUGIN_API int init();
 static int mmjack_configure(char* option, char* value);
 static int mmjack_configure_instance(instance* inst, char* option, char* value);
 static instance* mmjack_instance();
-static channel* mmjack_channel(instance* inst, char* spec);
+static channel* mmjack_channel(instance* inst, char* spec, uint8_t flags);
 static int mmjack_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int mmjack_handle(size_t num, managed_fd* fds);
 static int mmjack_start();
diff --git a/backends/loopback.c b/backends/loopback.c
index 0a45bde..41e6f85 100644
--- a/backends/loopback.c
+++ b/backends/loopback.c
@@ -49,7 +49,7 @@ static instance* loopback_instance(){
 	return i;
 }
 
-static channel* loopback_channel(instance* inst, char* spec){
+static channel* loopback_channel(instance* inst, char* spec, uint8_t flags){
 	size_t u;
 	loopback_instance_data* data = (loopback_instance_data*) inst->impl;
 
diff --git a/backends/loopback.h b/backends/loopback.h
index a08417b..ee51c66 100644
--- a/backends/loopback.h
+++ b/backends/loopback.h
@@ -4,7 +4,7 @@ MM_PLUGIN_API int init();
 static int loopback_configure(char* option, char* value);
 static int loopback_configure_instance(instance* inst, char* option, char* value);
 static instance* loopback_instance();
-static channel* loopback_channel(instance* inst, char* spec);
+static channel* loopback_channel(instance* inst, char* spec, uint8_t flags);
 static int loopback_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int loopback_handle(size_t num, managed_fd* fds);
 static int loopback_start();
diff --git a/backends/lua.c b/backends/lua.c
index 0b47b2c..40e6613 100644
--- a/backends/lua.c
+++ b/backends/lua.c
@@ -330,7 +330,7 @@ static instance* lua_instance(){
 	return inst;
 }
 
-static channel* lua_channel(instance* inst, char* spec){
+static channel* lua_channel(instance* inst, char* spec, uint8_t flags){
 	size_t u;
 	lua_instance_data* data = (lua_instance_data*) inst->impl;
 
diff --git a/backends/lua.h b/backends/lua.h
index e187a8e..4ea5b0a 100644
--- a/backends/lua.h
+++ b/backends/lua.h
@@ -13,7 +13,7 @@ MM_PLUGIN_API int init();
 static int lua_configure(char* option, char* value);
 static int lua_configure_instance(instance* inst, char* option, char* value);
 static instance* lua_instance();
-static channel* lua_channel(instance* inst, char* spec);
+static channel* lua_channel(instance* inst, char* spec, uint8_t flags);
 static int lua_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int lua_handle(size_t num, managed_fd* fds);
 static int lua_start();
diff --git a/backends/maweb.c b/backends/maweb.c
index 08156f2..d008cc0 100644
--- a/backends/maweb.c
+++ b/backends/maweb.c
@@ -229,7 +229,7 @@ static instance* maweb_instance(){
 	return inst;
 }
 
-static channel* maweb_channel(instance* inst, char* spec){
+static channel* maweb_channel(instance* inst, char* spec, uint8_t flags){
 	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
 	maweb_channel_data chan = {
 		0
diff --git a/backends/maweb.h b/backends/maweb.h
index 9091cda..05095f8 100644
--- a/backends/maweb.h
+++ b/backends/maweb.h
@@ -4,7 +4,7 @@ MM_PLUGIN_API int init();
 static int maweb_configure(char* option, char* value);
 static int maweb_configure_instance(instance* inst, char* option, char* value);
 static instance* maweb_instance();
-static channel* maweb_channel(instance* inst, char* spec);
+static channel* maweb_channel(instance* inst, char* spec, uint8_t flags);
 static int maweb_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int maweb_handle(size_t num, managed_fd* fds);
 static int maweb_start();
diff --git a/backends/midi.c b/backends/midi.c
index f380f59..92776ca 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -110,7 +110,7 @@ static int midi_configure_instance(instance* inst, char* option, char* value){
 	return 1;
 }
 
-static channel* midi_channel(instance* inst, char* spec){
+static channel* midi_channel(instance* inst, char* spec, uint8_t flags){
 	midi_channel_ident ident = {
 		.label = 0
 	};
diff --git a/backends/midi.h b/backends/midi.h
index b9934f1..4e16f90 100644
--- a/backends/midi.h
+++ b/backends/midi.h
@@ -4,7 +4,7 @@ MM_PLUGIN_API int init();
 static int midi_configure(char* option, char* value);
 static int midi_configure_instance(instance* instance, char* option, char* value);
 static instance* midi_instance();
-static channel* midi_channel(instance* instance, char* spec);
+static channel* midi_channel(instance* instance, char* spec, uint8_t flags);
 static int midi_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int midi_handle(size_t num, managed_fd* fds);
 static int midi_start();
diff --git a/backends/ola.cpp b/backends/ola.cpp
index d069a8c..c13e8f9 100644
--- a/backends/ola.cpp
+++ b/backends/ola.cpp
@@ -68,7 +68,7 @@ static int ola_configure_instance(instance* inst, char* option, char* value){
 	return 1;
 }
 
-static channel* ola_channel(instance* inst, char* spec){
+static channel* ola_channel(instance* inst, char* spec, uint8_t flags){
 	ola_instance_data* data = (ola_instance_data*) inst->impl;
 	char* spec_next = spec;
 	unsigned chan_a = strtoul(spec, &spec_next, 10);
diff --git a/backends/ola.h b/backends/ola.h
index 1637495..0c42bac 100644
--- a/backends/ola.h
+++ b/backends/ola.h
@@ -8,7 +8,7 @@ extern "C" {
 	static int ola_configure(char* option, char* value);
 	static int ola_configure_instance(instance* instance, char* option, char* value);
 	static instance* ola_instance();
-	static channel* ola_channel(instance* instance, char* spec);
+	static channel* ola_channel(instance* instance, char* spec, uint8_t flags);
 	static int ola_set(instance* inst, size_t num, channel** c, channel_value* v);
 	static int ola_handle(size_t num, managed_fd* fds);
 	static int ola_start();
diff --git a/backends/osc.c b/backends/osc.c
index d9f9139..757ad89 100644
--- a/backends/osc.c
+++ b/backends/osc.c
@@ -577,7 +577,7 @@ static instance* osc_instance(){
 	return inst;
 }
 
-static channel* osc_map_channel(instance* inst, char* spec){
+static channel* osc_map_channel(instance* inst, char* spec, uint8_t flags){
 	size_t u, p;
 	osc_instance_data* data = (osc_instance_data*) inst->impl;
 	osc_channel_ident ident = {
diff --git a/backends/osc.h b/backends/osc.h
index 86be285..6f3b923 100644
--- a/backends/osc.h
+++ b/backends/osc.h
@@ -11,7 +11,7 @@ MM_PLUGIN_API int init();
 static int osc_configure(char* option, char* value);
 static int osc_configure_instance(instance* inst, char* option, char* value);
 static instance* osc_instance();
-static channel* osc_map_channel(instance* inst, char* spec);
+static channel* osc_map_channel(instance* inst, char* spec, uint8_t flags);
 static int osc_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int osc_handle(size_t num, managed_fd* fds);
 static int osc_start();
diff --git a/backends/sacn.c b/backends/sacn.c
index d8b3eb3..2229b8a 100644
--- a/backends/sacn.c
+++ b/backends/sacn.c
@@ -198,7 +198,7 @@ static instance* sacn_instance(){
 	return inst;
 }
 
-static channel* sacn_channel(instance* inst, char* spec){
+static channel* sacn_channel(instance* inst, char* spec, uint8_t flags){
 	sacn_instance_data* data = (sacn_instance_data*) inst->impl;
 	char* spec_next = spec;
 
diff --git a/backends/sacn.h b/backends/sacn.h
index 631d3a4..1d3268c 100644
--- a/backends/sacn.h
+++ b/backends/sacn.h
@@ -4,7 +4,7 @@ MM_PLUGIN_API int init();
 static int sacn_configure(char* option, char* value);
 static int sacn_configure_instance(instance* instance, char* option, char* value);
 static instance* sacn_instance();
-static channel* sacn_channel(instance* instance, char* spec);
+static channel* sacn_channel(instance* instance, char* spec, uint8_t flags);
 static int sacn_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int sacn_handle(size_t num, managed_fd* fds);
 static int sacn_start();
diff --git a/backends/winmidi.c b/backends/winmidi.c
index b274c06..790257b 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -110,7 +110,7 @@ static instance* winmidi_instance(){
 	return i;
 }
 
-static channel* winmidi_channel(instance* inst, char* spec){
+static channel* winmidi_channel(instance* inst, char* spec, uint8_t flags){
 	char* next_token = NULL;
 	winmidi_channel_ident ident = {
 		.label = 0
diff --git a/backends/winmidi.h b/backends/winmidi.h
index 8c2d76b..985c46a 100644
--- a/backends/winmidi.h
+++ b/backends/winmidi.h
@@ -4,7 +4,7 @@ MM_PLUGIN_API int init();
 static int winmidi_configure(char* option, char* value);
 static int winmidi_configure_instance(instance* inst, char* option, char* value);
 static instance* winmidi_instance();
-static channel* winmidi_channel(instance* inst, char* spec);
+static channel* winmidi_channel(instance* inst, char* spec, uint8_t flags);
 static int winmidi_set(instance* inst, size_t num, channel** c, channel_value* v);
 static int winmidi_handle(size_t num, managed_fd* fds);
 static int winmidi_start();
diff --git a/config.c b/config.c
index 8e7e581..0b9173e 100644
--- a/config.c
+++ b/config.c
@@ -175,7 +175,7 @@ static int config_glob_scan(instance* inst, channel_spec* spec){
 	return 0;
 }
 
-static channel* config_glob_resolve(instance* inst, channel_spec* spec, uint64_t n){
+static channel* config_glob_resolve(instance* inst, channel_spec* spec, uint64_t n, uint8_t map_direction){
 	size_t glob = 0, glob_length;
 	ssize_t bytes = 0;
 	uint64_t current_value = 0;
@@ -216,7 +216,7 @@ static channel* config_glob_resolve(instance* inst, channel_spec* spec, uint64_t
 		}
 	}
 
-	result = inst->backend->channel(inst, resolved_spec);
+	result = inst->backend->channel(inst, resolved_spec, map_direction);
 	if(spec->globs && !result){
 		fprintf(stderr, "Failed to match multichannel evaluation %s to a channel\n", resolved_spec);
 	}
@@ -294,8 +294,8 @@ static int config_map(char* to_raw, char* from_raw){
 	//iterate, resolve globs and map
 	rv = 0;
 	for(n = 0; !rv && n < max(spec_from.channels, spec_to.channels); n++){
-		channel_from = config_glob_resolve(instance_from, &spec_from, min(n, spec_from.channels));
-		channel_to = config_glob_resolve(instance_to, &spec_to, min(n, spec_to.channels));
+		channel_from = config_glob_resolve(instance_from, &spec_from, min(n, spec_from.channels), mmchannel_input);
+		channel_to = config_glob_resolve(instance_to, &spec_to, min(n, spec_to.channels), mmchannel_output);
 		
 		if(!channel_from || !channel_to){
 			rv = 1;
diff --git a/midimonster.h b/midimonster.h
index 1192d6a..5ce0c73 100644
--- a/midimonster.h
+++ b/midimonster.h
@@ -87,8 +87,11 @@ struct _managed_fd;
  * 		Parse instance configuration from the user-supplied configuration
  * 		file. Returning a non-zero value fails config parsing.
  * 	* mmbackend_channel
- * 		Parse a channel-spec to be mapped to/from. Returning NULL signals an
- * 		out-of-memory condition and terminates the program.
+ * 		Parse a channel-spec to be mapped to/from. The `falgs` parameter supplies
+ * 		additional information to the parser, such as whether the channel is being
+ * 		queried for use as input (to the MIDIMonster core) and/or output
+ * 		(from the MIDIMonster core) channel (on a per-query basis).
+ * 		Returning NULL signals an out-of-memory condition and terminates the program.
  * 	* mmbackend_start
  * 		Called after all instances have been created and all mappings
  * 		have been set up. Only backends for which instances have been configured
@@ -121,7 +124,7 @@ struct _managed_fd;
  */
 typedef int (*mmbackend_handle_event)(struct _backend_instance* inst, size_t channels, struct _backend_channel** c, struct _channel_value* v);
 typedef struct _backend_instance* (*mmbackend_create_instance)();
-typedef struct _backend_channel* (*mmbackend_parse_channel)(struct _backend_instance* instance, char* spec);
+typedef struct _backend_channel* (*mmbackend_parse_channel)(struct _backend_instance* instance, char* spec, uint8_t flags);
 typedef void (*mmbackend_free_channel)(struct _backend_channel* c);
 typedef int (*mmbackend_configure)(char* option, char* value);
 typedef int (*mmbackend_configure_instance)(struct _backend_instance* instance, char* option, char* value);
@@ -130,6 +133,12 @@ typedef int (*mmbackend_start)();
 typedef uint32_t (*mmbackend_interval)();
 typedef int (*mmbackend_shutdown)();
 
+/* Bit masks for the `flags` parameter to mmbackend_parse_channel */
+typedef enum {
+	mmchannel_input = 0x1,
+	mmchannel_output = 0x2
+} mmbe_channel_flags;
+
 /* Channel event value, .normalised is used by backends to determine channel values */
 typedef struct _channel_value {
 	union {
-- 
cgit v1.2.3