From 62b41d0b2ea58b48961308ab24fe4287365b2d50 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 6 Jul 2019 17:44:10 +0200
Subject: evdev backend code style fixes

---
 TODO | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'TODO')

diff --git a/TODO b/TODO
index dd3022b..cfdd409 100644
--- a/TODO
+++ b/TODO
@@ -1,5 +1,8 @@
 MIDI NRPN
 Note source in channel value struct
 Optimize core channel search (store backend offset)
-Function generator
 Printing backend
+
+document example configs
+lua timer
+evdev relaxes size
-- 
cgit v1.2.3


From ee4a46105acecb6a7adc1e7189e8b0a66404b421 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 13 Jul 2019 17:51:11 +0200
Subject: Improved Lua backend with intervals

---
 TODO             |   2 +-
 backends/lua.c   | 302 +++++++++++++++++++++++++++++++++++++++++++++++++++----
 backends/lua.h   |  10 ++
 backends/lua.md  |  32 ++++--
 configs/demo.lua |  45 ++++++---
 configs/lua.cfg  |  10 +-
 6 files changed, 359 insertions(+), 42 deletions(-)

(limited to 'TODO')

diff --git a/TODO b/TODO
index cfdd409..f39dae0 100644
--- a/TODO
+++ b/TODO
@@ -5,4 +5,4 @@ Printing backend
 
 document example configs
 lua timer
-evdev relaxes size
+evdev relative axis size
diff --git a/backends/lua.c b/backends/lua.c
index ae2d460..08d8d3c 100644
--- a/backends/lua.c
+++ b/backends/lua.c
@@ -1,10 +1,18 @@
 #include <string.h>
+#include <sys/timerfd.h>
+#include <unistd.h>
+#include <errno.h>
 #include "lua.h"
 
 #define BACKEND_NAME "lua"
 #define LUA_REGISTRY_KEY "_midimonster_lua_instance"
 
-//TODO instance identification for callvacks
+static size_t timers = 0;
+static lua_timer* timer = NULL;
+static struct itimerspec timer_config = {
+	0
+};
+static int timer_fd = -1;
 
 int init(){
 	backend lua = {
@@ -24,31 +32,83 @@ int init(){
 		fprintf(stderr, "Failed to register lua backend\n");
 		return 1;
 	}
+
+	//create the timer to expire intervals
+	timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+	if(timer_fd < 0){
+		fprintf(stderr, "Failed to create timer for Lua backend\n");
+		return 1;
+	}
+	return 0;
+}
+
+static int lua_update_timerfd(){
+	uint64_t interval = 0, gcd, residual;
+	size_t n = 0;
+
+	//find the minimum for the lower interval bounds
+	for(n = 0; n < timers; n++){
+		if(timer[n].interval && (!interval || timer[n].interval < interval)){
+			interval = timer[n].interval;
+		}
+	}
+
+	//stop the timer
+	if(!interval){
+		memset(&timer_config, 0, sizeof(struct itimerspec));
+	}
+	//calculate gcd of all timers
+	else{
+		for(n = 0; n < timers; n++){
+			if(timer[n].interval){
+				//calculate gcd of current interval and this timers interval
+				gcd = timer[n].interval;
+				while(gcd){
+					residual = interval % gcd;
+					interval = gcd;
+					gcd = residual;
+				}
+				//since we round everything, 10 is the lowest interval we get
+				if(interval == 10){
+					break;
+				}
+			}
+		}
+
+		timer_config.it_interval.tv_sec = interval / 1000;
+		timer_config.it_interval.tv_nsec = (interval % 1000) * 1e6;
+		timer_config.it_value.tv_nsec = 1;
+	}
+
+	//configure the new interval
+	timerfd_settime(timer_fd, 0, &timer_config, NULL);
 	return 0;
 }
 
 static int lua_callback_output(lua_State* interpreter){
-	int arguments = lua_gettop(interpreter);
-	size_t n;
+	size_t n = 0;
 	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);
+	if(lua_gettop(interpreter) != 2){
+		fprintf(stderr, "Lua output function called with %d arguments, expected 2 (string, number)\n", lua_gettop(interpreter));
 		return 0;
 	}
 
-	channel_name = lua_tostring(interpreter, 1);
-	val.normalised = clamp(lua_tonumber(interpreter, 2), 1.0, 0.0);
-
+	//get instance pointer from registry
 	lua_pushstring(interpreter, LUA_REGISTRY_KEY);
 	lua_gettable(interpreter, LUA_REGISTRYINDEX);
-	inst = (instance *) lua_touserdata(interpreter, -1);
+	inst = (instance*) lua_touserdata(interpreter, -1);
 	data = (lua_instance_data*) inst->impl;
 
+	//fetch function parameters
+	channel_name = lua_tostring(interpreter, 1);
+	val.normalised = clamp(luaL_checknumber(interpreter, 2), 1.0, 0.0);
+
+	//find correct channel & output value
 	for(n = 0; n < data->channels; n++){
 		if(!strcmp(channel_name, data->channel_name[n])){
 			channel = mm_channel(inst, n, 0);
@@ -56,6 +116,7 @@ static int lua_callback_output(lua_State* interpreter){
 				return 0;
 			}
 			mm_channel_event(channel, val);
+			data->output[n] = val.normalised;
 			return 0;
 		}
 	}
@@ -64,6 +125,122 @@ static int lua_callback_output(lua_State* interpreter){
 	return 0;
 }
 
+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;
+
+	if(lua_gettop(interpreter) != 2){
+		fprintf(stderr, "Lua output function called with %d arguments, expected 2 (string, number)\n", lua_gettop(interpreter));
+		return 0;
+	}
+
+	//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);
+	if(interval % 10 < 5){
+		interval -= interval % 10;
+	}
+	else{
+		interval += (10 - (interval % 10));
+	}
+
+	//push the function again
+	lua_pushvalue(interpreter, 1);
+	if(lua_gettable(interpreter, LUA_REGISTRYINDEX) == LUA_TNUMBER){
+		//already interval'd
+		reference = luaL_checkinteger(interpreter, 4);
+	}
+	else if(interval){
+		//get a reference to the function
+		lua_pushvalue(interpreter, 1);
+		reference = luaL_ref(interpreter, LUA_REGISTRYINDEX);
+
+		//the function indexes the reference
+		lua_pushvalue(interpreter, 1);
+		lua_pushinteger(interpreter, reference);
+		lua_settable(interpreter, LUA_REGISTRYINDEX);
+	}
+
+	//find matching timer
+	for(n = 0; n < timers; n++){
+		if(timer[n].reference == reference && timer[n].interpreter == interpreter){
+			break;
+		}
+	}
+
+	if(n < timers){
+		//set new interval
+		timer[n].interval = interval;
+		timer[n].delta = 0;
+	}
+	else if(interval){
+		//append new timer
+		timer = realloc(timer, (timers + 1) * sizeof(lua_timer));
+		if(!timer){
+			fprintf(stderr, "Failed to allocate memory\n");
+			timers = 0;
+			return 0;
+		}
+		timer[timers].interval = interval;
+		timer[timers].delta = 0;
+		timer[timers].interpreter = interpreter;
+		timer[timers].reference = reference;
+		timers++;
+	}
+
+	//recalculate timerspec
+	lua_update_timerfd();
+	return 0;
+}
+
+static int lua_callback_value(lua_State* interpreter, uint8_t input){
+	size_t n = 0;
+	instance* inst = NULL;
+	lua_instance_data* data = NULL;
+	const char* channel_name = NULL;
+
+	if(lua_gettop(interpreter) != 1){
+		fprintf(stderr, "Lua get_value function called with %d arguments, expected 1 (string)\n", lua_gettop(interpreter));
+		return 0;
+	}
+
+	//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 argument
+	channel_name = lua_tostring(interpreter, 1);
+
+	//find correct channel & return value
+	for(n = 0; n < data->channels; n++){
+		if(!strcmp(channel_name, data->channel_name[n])){
+			lua_pushnumber(data->interpreter, (input) ? data->input[n] : data->output[n]);
+			return 1;
+		}
+	}
+
+	fprintf(stderr, "Tried to get unknown channel %s.%s\n", inst->name, channel_name);
+	return 0;
+}
+
+static int lua_callback_input_value(lua_State* interpreter){
+	return lua_callback_value(interpreter, 1);
+}
+
+static int lua_callback_output_value(lua_State* interpreter){
+	return lua_callback_value(interpreter, 0);
+}
+
 static int lua_configure(char* option, char* value){
 	fprintf(stderr, "The lua backend does not take any global configuration\n");
 	return 1;
@@ -72,6 +249,7 @@ static int lua_configure(char* option, char* value){
 static int lua_configure_instance(instance* inst, char* option, char* value){
 	lua_instance_data* data = (lua_instance_data*) inst->impl;
 
+	//load a lua file into the interpreter
 	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));
@@ -105,13 +283,16 @@ static instance* lua_instance(){
 	}
 	luaL_openlibs(data->interpreter);
 
-	//register lua api functions
+	//register lua interface functions
 	lua_register(data->interpreter, "output", lua_callback_output);
+	lua_register(data->interpreter, "interval", lua_callback_interval);
+	lua_register(data->interpreter, "input_value", lua_callback_input_value);
+	lua_register(data->interpreter, "output_value", lua_callback_output_value);
 
 	//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);   
+	lua_settable(data->interpreter, LUA_REGISTRYINDEX);
 
 	inst->impl = data;
 	return inst;
@@ -131,11 +312,16 @@ static channel* lua_channel(instance* inst, char* spec){
 	//allocate new channel
 	if(u == data->channels){
 		data->channel_name = realloc(data->channel_name, (u + 1) * sizeof(char*));
-		if(!data->channel_name){
+		data->reference = realloc(data->reference, (u + 1) * sizeof(int));
+		data->input = realloc(data->input, (u + 1) * sizeof(double));
+		data->output = realloc(data->output, (u + 1) * sizeof(double));
+		if(!data->channel_name || !data->reference || !data->input || !data->output){
 			fprintf(stderr, "Failed to allocate memory\n");
 			return NULL;
 		}
 
+		data->reference[u] = LUA_NOREF;
+		data->input[u] = data->output[u] = 0.0;
 		data->channel_name[u] = strdup(spec);
 		if(!data->channel_name[u]){
 			fprintf(stderr, "Failed to allocate memory\n");
@@ -151,25 +337,91 @@ 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;
 
+	//handle all incoming events
 	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);
+		data->input[c[n]->ident] = v[n].normalised;
+		//call lua channel handlers if present
+		if(data->reference[n] != LUA_NOREF){
+			lua_rawgeti(data->interpreter, LUA_REGISTRYINDEX, data->reference[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
+	uint8_t read_buffer[100];
+	uint64_t delta = timer_config.it_interval.tv_sec * 1000 + timer_config.it_interval.tv_nsec / 1e6;
+	size_t n;
+
+	if(!num){
+		return 0;
+	}
+
+	//read the timer iteration to acknowledge the fd
+	if(read(timer_fd, read_buffer, sizeof(read_buffer)) < 0){
+		fprintf(stderr, "Failed to read from Lua timer: %s\n", strerror(errno));
+		return 1;
+	}
+
+	//add delta to all active timers
+	for(n = 0; n < timers; n++){
+		if(timer[n].interval){
+			timer[n].delta += delta;
+			//call lua function if timer expired
+			if(timer[n].delta >= timer[n].interval){
+				timer[n].delta %= timer[n].interval;
+				lua_rawgeti(timer[n].interpreter, LUA_REGISTRYINDEX, timer[n].reference);
+				lua_pcall(timer[n].interpreter, 0, 0, 0);
+			}
+		}
+	}
 	return 0;
 }
 
 static int lua_start(){
-	//TODO start timers / register fds
+	size_t n, u, p;
+	instance** inst = NULL;
+	lua_instance_data* data = NULL;
+
+	//fetch all defined instances
+	if(mm_backend_instances(BACKEND_NAME, &n, &inst)){
+		fprintf(stderr, "Failed to fetch instance list\n");
+		return 1;
+	}
+
+	//resolve channels to their handler functions
+	for(u = 0; u < n; u++){
+		data = (lua_instance_data*) inst[u]->impl;
+		for(p = 0; p < data->channels; p++){
+			//exclude reserved names
+			if(strcmp(data->channel_name[p], "output")
+					&& strcmp(data->channel_name[p], "input_value")
+					&& strcmp(data->channel_name[p], "output_value")
+					&& strcmp(data->channel_name[p], "interval")){
+				lua_getglobal(data->interpreter, data->channel_name[p]);
+				data->reference[p] = luaL_ref(data->interpreter, LUA_REGISTRYINDEX);
+				if(data->reference[p] == LUA_REFNIL){
+					data->reference[p] = LUA_NOREF;
+				}
+			}
+		}
+	}
+
+	free(inst);
+	if(!n){
+		return 0;
+	}
+
+	//register the timer with the core
+	fprintf(stderr, "Lua backend registering 1 descriptor to core\n");
+	if(mm_manage_fd(timer_fd, BACKEND_NAME, 1, NULL)){
+		return 1;
+	}
 	return 0;
 }
 
@@ -178,6 +430,7 @@ static int lua_shutdown(){
 	instance** inst = NULL;
 	lua_instance_data* data = NULL;
 
+	//fetch all instances
 	if(mm_backend_instances(BACKEND_NAME, &n, &inst)){
 		fprintf(stderr, "Failed to fetch instance list\n");
 		return 1;
@@ -192,10 +445,19 @@ static int lua_shutdown(){
 			free(data->channel_name[p]);
 		}
 		free(data->channel_name);
+		free(data->reference);
+		free(data->input);
+		free(data->output);
 		free(inst[u]->impl);
 	}
 
 	free(inst);
+	//free module-global data
+	free(timer);
+	timer = NULL;
+	timers = 0;
+	close(timer_fd);
+	timer_fd = -1;
 
 	fprintf(stderr, "Lua backend shut down\n");
 	return 0;
diff --git a/backends/lua.h b/backends/lua.h
index 27e1afd..ccffef7 100644
--- a/backends/lua.h
+++ b/backends/lua.h
@@ -17,5 +17,15 @@ static int lua_shutdown();
 typedef struct /*_lua_instance_data*/ {
 	size_t channels;
 	char** channel_name;
+	int* reference;
+	double* input;
+	double* output;
 	lua_State* interpreter;
 } lua_instance_data;
+
+typedef struct /*_lua_interval_callback*/ {
+	uint64_t interval;
+	uint64_t delta;
+	lua_State* interpreter;
+	int reference;
+} lua_timer;
diff --git a/backends/lua.md b/backends/lua.md
index 91e8fe2..970e8e2 100644
--- a/backends/lua.md
+++ b/backends/lua.md
@@ -5,15 +5,32 @@ 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)`.
+To process incoming channel events, the MIDIMonster calls corresponding Lua functions (if they exist)
+with the value (as a Lua `number` type) as parameter.
+
+The following functions are provided within the Lua interpreter for interaction with the MIDIMonster
+
+| Function			| Usage example			| Description				|
+|-------------------------------|-------------------------------|---------------------------------------|
+| `output(string, number)`	| `output("foo", 0.75)`		| Output a value event to a channel	|
+| `interval(function, number)`	| `interval(update, 100)`	| Register a function to be called periodically. Intervals are milliseconds (rounded to the nearest 10 ms) |
+| `input_value(string)`		| `input_value("foo")`		| Get the last input value on a channel	|
+| `output_value(string)`	| `output_value("bar")		| Get the last output value on a channel |
+
 
 Example script:
 ```
 function bar(value)
 	output("foo", value / 2)
 end
+
+step = 0
+function toggle()
+	output("bar", step * 1.0)
+	step = (step + 1) % 2;
+end
+
+interval(toggle, 1000)
 ```
 
 Input values range between 0.0 and 1.0, output values are clamped to the same range.
@@ -41,9 +58,12 @@ 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.
+Using any of the interface functions (`output`, `interval`, `input\_value`, `output\_value`) as an
+input channel name to a Lua instance will not call any handler functions.
+Using these names as arguments to the output and value interface functions works as intended.
+
+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/configs/demo.lua b/configs/demo.lua
index e816ac4..24a8396 100644
--- a/configs/demo.lua
+++ b/configs/demo.lua
@@ -1,21 +1,42 @@
--- This example MIDIMonstaer Lua script spreads one input channel onto multiple output
+-- This example MIDIMonster 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)
+function polynomial(x)
+	return math.exp(-40 * input_value("width") * (x - input_value("offset")) ^ 2)
 end
 
--- Handler function for the input channel
-function input(value)
-	foo = foo + 1
-	print("input at ", value, foo)
-
+-- Evaluate and set output channels
+function evaluate()
 	for chan=0,10 do
-		output("out" .. chan, polynomial(value, (1 / 10) * chan))
+		output("out" .. chan, polynomial((1 / 10) * chan))
+	end
+end
+
+-- Handler functions for the input channels
+function offset(value)
+	evaluate()
+end
+
+function width(value)
+	evaluate()
+end
+
+-- This is an example showing a simple chase running on its own without the need
+-- (but the possibility) for external input
+
+-- Global value for the current step
+current_step = 0
+
+function step()
+	if(current_step > 0) then
+		output("dim", 0.0)
+	else
+		output("dim", 1.0)
 	end
+		
+	current_step = (current_step + 1) % 2
 end
+
+interval(step, 1000)
diff --git a/configs/lua.cfg b/configs/lua.cfg
index 9182122..42fd27d 100644
--- a/configs/lua.cfg
+++ b/configs/lua.cfg
@@ -8,8 +8,9 @@ bind = 0.0.0.0
 device = /dev/input/by-path/platform-i8042-serio-2-event-mouse
 
 [evdev xbox]
-input = Xbox Wireless
+device = /dev/input/event17
 axis.ABS_X = 34300 0 65535 255 4095
+axis.ABS_Y = 34300 0 65535 255 4095
 
 [lua lua]
 script = configs/demo.lua
@@ -19,8 +20,9 @@ universe = 0
 destination = 255.255.255.255
 
 [map]
-mouse.EV_KEY.BTN_LEFT > lua.input
-xbox.EV_ABS.ABS_X > lua.input
+mouse.EV_KEY.BTN_LEFT > lua.click
+xbox.EV_ABS.ABS_X > lua.offset
+xbox.EV_ABS.ABS_Y > lua.width
 
 art.1 < lua.out0
 art.2 < lua.out1
@@ -33,3 +35,5 @@ art.8 < lua.out7
 art.9 < lua.out8
 art.10 < lua.out9
 art.11 < lua.out10
+
+art.12 < lua.dim
-- 
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 'TODO')

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 1f0de6d91c14217ae3893da0e4b6089b799ed026 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Wed, 24 Jul 2019 21:30:40 +0200
Subject: Update example configurations to new syntax, add comments

---
 TODO                       |   2 +-
 configs/evdev.cfg          |  32 ++++++++
 configs/evdev.conf         |  31 --------
 configs/launchctl-sacn.cfg |  10 +--
 configs/lua.cfg            |  13 +--
 configs/midi-osc.cfg       |  25 ++----
 configs/osc-artnet.cfg     |  51 +-----------
 configs/osc-kbd.cfg        |  16 +---
 configs/unifest-17.cfg     | 191 +++++++++------------------------------------
 9 files changed, 82 insertions(+), 289 deletions(-)
 create mode 100644 configs/evdev.cfg
 delete mode 100644 configs/evdev.conf

(limited to 'TODO')

diff --git a/TODO b/TODO
index 76f2c4e..d114640 100644
--- a/TODO
+++ b/TODO
@@ -1,7 +1,7 @@
 MIDI NRPN
 Note source in channel value struct
 Optimize core channel search (store backend offset)
-Printing backend
+Printing backend / Verbose mode
 
 document example configs
 evdev relative axis size
diff --git a/configs/evdev.cfg b/configs/evdev.cfg
new file mode 100644
index 0000000..bb27caf
--- /dev/null
+++ b/configs/evdev.cfg
@@ -0,0 +1,32 @@
+; Map the (admittedly weird) bluetooth profile of an Xbox One
+; Gamepad to some ArtNet output channels. Uses both analog joysticks
+; and the analog triggers.
+
+[backend artnet]
+bind = 0.0.0.0 6454
+net = 0
+
+[evdev xbox]
+device = /dev/input/event14
+
+[artnet out]
+uni = 0
+dest = 255.255.255.255
+
+[map]
+xbox.EV_ABS.ABS_X > out.1+2
+xbox.EV_ABS.ABS_Y > out.3+4
+
+xbox.EV_ABS.ABS_Z > out.16+17
+xbox.EV_ABS.ABS_RZ > out.18+19
+
+xbox.EV_ABS.ABS_BRAKE > out.8
+xbox.EV_ABS.ABS_GAS > out.23
+
+xbox.EV_KEY.BTN_NORTH > out.5
+xbox.EV_KEY.BTN_EAST > out.6
+xbox.EV_KEY.BTN_SOUTH > out.7
+
+xbox.EV_KEY.BTN_NORTH > out.20
+xbox.EV_KEY.BTN_EAST > out.21
+xbox.EV_KEY.BTN_SOUTH > out.22
diff --git a/configs/evdev.conf b/configs/evdev.conf
deleted file mode 100644
index 386e154..0000000
--- a/configs/evdev.conf
+++ /dev/null
@@ -1,31 +0,0 @@
-[backend artnet]
-bind = * 6454
-net = 0
-
-[evdev xbox]
-device = /dev/input/event14
-axis.ABS_X = 34300 0 65535 255 4095
-axis.ABS_RZ = 34300 0 65535 255 4095
-axis.ABS_Y = 34300 0 65535 255 4095
-
-[artnet out]
-uni = 0
-dest = 129.13.215.127
-
-[map]
-xbox.EV_ABS.ABS_X > out.1+2
-xbox.EV_ABS.ABS_Y > out.3+4
-
-xbox.EV_ABS.ABS_Z > out.16+17
-xbox.EV_ABS.ABS_RZ > out.18+19
-
-xbox.EV_ABS.ABS_BRAKE > out.8
-xbox.EV_ABS.ABS_GAS > out.23
-
-xbox.EV_KEY.BTN_NORTH > out.5
-xbox.EV_KEY.BTN_EAST > out.6
-xbox.EV_KEY.BTN_SOUTH > out.7
-
-xbox.EV_KEY.BTN_NORTH > out.20
-xbox.EV_KEY.BTN_EAST > out.21
-xbox.EV_KEY.BTN_SOUTH > out.22
diff --git a/configs/launchctl-sacn.cfg b/configs/launchctl-sacn.cfg
index 02cd152..781ca40 100644
--- a/configs/launchctl-sacn.cfg
+++ b/configs/launchctl-sacn.cfg
@@ -19,12 +19,4 @@ destination = 255.255.255.255
 [map]
 
 lc.ch0.cc{0..15} > out.{1..16}
-
-lc.ch0.note0 > out.1
-lc.ch0.note1 > out.2
-lc.ch0.note2 > out.3
-lc.ch0.note3 > out.4
-lc.ch0.note4 > out.5
-lc.ch0.note5 > out.6
-lc.ch0.note6 > out.7
-lc.ch0.note7 > out.8
+lc.ch0.note{0..7} > out.{1..8}
diff --git a/configs/lua.cfg b/configs/lua.cfg
index b892e91..af17496 100644
--- a/configs/lua.cfg
+++ b/configs/lua.cfg
@@ -24,16 +24,5 @@ mouse.EV_KEY.BTN_LEFT > lua.click
 xbox.EV_ABS.ABS_X > lua.offset
 xbox.EV_ABS.ABS_Y > lua.width
 
-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
-
+art.{1..11} < lua.out{0..10}
 art.12 < lua.dim
diff --git a/configs/midi-osc.cfg b/configs/midi-osc.cfg
index 755077c..1b3ccd6 100644
--- a/configs/midi-osc.cfg
+++ b/configs/midi-osc.cfg
@@ -1,14 +1,18 @@
+; Translate a MIDI fader wing into an OSC fader view and vice versa
+
 [backend midi]
 name = MIDIMonster
 
 [backend artnet]
-bind = * 6454
+bind = 0.0.0.0 6454
 net = 0
 
 [osc touch]
 bind = * 8000
 dest = learn@8000
 root = /4
+
+; Pre-declare the fader values so the range mapping is correct
 /fader1 = f 0.0 1.0
 /fader2 = f 0.0 1.0
 /fader3 = f 0.0 1.0
@@ -33,20 +37,5 @@ write = BCF
 
 [map]
 
-bcf.ch0.cc81 <> touch./fader1
-bcf.ch0.cc82 <> touch./fader2
-bcf.ch0.cc83 <> touch./fader3
-bcf.ch0.cc84 <> touch./fader4
-bcf.ch0.cc85 <> touch./fader5
-bcf.ch0.cc86 <> touch./fader6
-bcf.ch0.cc87 <> touch./fader7
-bcf.ch0.cc88 <> touch./fader8
-
-bcf.ch0.cc81 <> touch./multifader1/1
-bcf.ch0.cc82 <> touch./multifader1/2
-bcf.ch0.cc83 <> touch./multifader1/3
-bcf.ch0.cc84 <> touch./multifader1/4
-bcf.ch0.cc85 <> touch./multifader1/5
-bcf.ch0.cc86 <> touch./multifader1/6
-bcf.ch0.cc87 <> touch./multifader1/7
-bcf.ch0.cc88 <> touch./multifader1/8
+bcf.ch0.cc{81..88} <> touch./fader{1..8}
+bcf.ch0.cc{81..88} <> touch./multifader1/{1..8}
diff --git a/configs/osc-artnet.cfg b/configs/osc-artnet.cfg
index 3eeba2e..ab1d767 100644
--- a/configs/osc-artnet.cfg
+++ b/configs/osc-artnet.cfg
@@ -12,52 +12,5 @@ dest = learn@8001
 destination = 255.255.255.255
 
 [map]
-touch./4/multifader1/1 > out.1
-touch./4/multifader1/2 > out.2
-touch./4/multifader1/3 > out.3
-touch./4/multifader1/4 > out.4
-touch./4/multifader1/5 > out.5
-touch./4/multifader1/6 > out.6
-touch./4/multifader1/7 > out.7
-touch./4/multifader1/8 > out.8
-touch./4/multifader1/9 > out.9
-touch./4/multifader1/10 > out.10
-touch./4/multifader1/11 > out.11
-touch./4/multifader1/12 > out.12
-touch./4/multifader1/13 > out.13
-touch./4/multifader1/14 > out.14
-touch./4/multifader1/15 > out.15
-touch./4/multifader1/16 > out.16
-touch./4/multifader1/17 > out.17
-touch./4/multifader1/18 > out.18
-touch./4/multifader1/19 > out.19
-touch./4/multifader1/20 > out.20
-touch./4/multifader1/21 > out.21
-touch./4/multifader1/22 > out.22
-touch./4/multifader1/23 > out.23
-touch./4/multifader1/24 > out.24
-
-touch./4/multifader2/1 > out.25
-touch./4/multifader2/2 > out.26
-touch./4/multifader2/3 > out.27
-touch./4/multifader2/4 > out.28
-touch./4/multifader2/5 > out.29
-touch./4/multifader2/6 > out.30
-touch./4/multifader2/7 > out.31
-touch./4/multifader2/8 > out.32
-touch./4/multifader2/9 > out.33
-touch./4/multifader2/10 > out.34
-touch./4/multifader2/11 > out.35
-touch./4/multifader2/12 > out.36
-touch./4/multifader2/13 > out.37
-touch./4/multifader2/14 > out.38
-touch./4/multifader2/15 > out.39
-touch./4/multifader2/16 > out.40
-touch./4/multifader2/17 > out.41
-touch./4/multifader2/18 > out.42
-touch./4/multifader2/19 > out.43
-touch./4/multifader2/20 > out.44
-touch./4/multifader2/21 > out.45
-touch./4/multifader2/22 > out.46
-touch./4/multifader2/23 > out.47
-touch./4/multifader2/24 > out.48
+touch./4/multifader1/{1..24} > out.{1..24}
+touch./4/multifader2/{1..24} > out.{25..48}
diff --git a/configs/osc-kbd.cfg b/configs/osc-kbd.cfg
index eb80378..bd2e2c0 100644
--- a/configs/osc-kbd.cfg
+++ b/configs/osc-kbd.cfg
@@ -1,4 +1,5 @@
-; Maps a TouchOSC simpl keyboard layout to MIDI notes
+; Maps a TouchOSC simple keyboard layout to MIDI notes
+; and writes them out to a FLUIDSynth instance
 
 [backend midi]
 name = MIDIMonster
@@ -11,15 +12,4 @@ bind = * 8000
 dest = learn@8001
 
 [map]
-pad./1/push1 > out.ch0.note60
-pad./1/push2 > out.ch0.note61
-pad./1/push3 > out.ch0.note62
-pad./1/push4 > out.ch0.note63
-pad./1/push5 > out.ch0.note64
-pad./1/push6 > out.ch0.note65
-pad./1/push7 > out.ch0.note66
-pad./1/push8 > out.ch0.note67
-pad./1/push9 > out.ch0.note68
-pad./1/push10 > out.ch0.note69
-pad./1/push11 > out.ch0.note70
-pad./1/push12 > out.ch0.note71
+pad./1/push{1..12} > out.ch0.note{60..71}
diff --git a/configs/unifest-17.cfg b/configs/unifest-17.cfg
index 47e9ec2..2504550 100644
--- a/configs/unifest-17.cfg
+++ b/configs/unifest-17.cfg
@@ -1,27 +1,36 @@
-; Note that this configuration file was originally written with
-; an older syntax and thus only contains right-to-left mappings
+; This configuration was used as central control translator for the following tasks
+; * Translate 2 Fader Wings and 2 Launch Control from MIDI CC to MIDI notes
+;	to be used as input to the GrandMA (connected to OUT A on Fader 1)
+;		Since both fader wings have the same name, we need to refer to them by portid
+;		-> Instances fader1, fader2, lc2, grandma
+; * Remap buttons from a LaunchPad as input to the GrandMA
+;		-> Instances launchpad, grandma
+; * Translate the rotaries of one Launch Control to ArtNet for additional effect control
+;		-> Instances lc1, xlaser
+; 
+; Note that the MIDI port specifications might not be reusable 1:1
 
 [backend midi]
 name = MIDIMonster
 
 [backend artnet]
-bind = * 6454
+bind = 0.0.0.0 6454
 net = 0
 
 ; XLaser environment
-[artnet claudius]
-uni = 0
+[artnet xlaser]
+universe = 0
 
 ; MIDI input devices
-[midi pad]
+[midi launchpad]
 read = Launchpad
 write = Launchpad
 
-[midi bcf1]
+[midi fader1]
 read = 20:0
 write = 20:0
 
-[midi bcf2]
+[midi fader2]
 read = 36:0
 write = 36:0
 
@@ -34,162 +43,32 @@ read = 32:0
 write = 32:0
 
 ; Output MIDI via OUT A on BCF
-[midi out]
+[midi grandma]
 write = 36:1
 read = 36:1
 
 [map]
-; ArtNet
-claudius.1 < lc1.ch0.cc1
-claudius.2 < lc1.ch0.cc2
-claudius.3 < lc1.ch0.cc3
-claudius.4 < lc1.ch0.cc4
-claudius.5 < lc1.ch0.cc5
-claudius.6 < lc1.ch0.cc6
-claudius.7 < lc1.ch0.cc7
-claudius.8 < lc1.ch0.cc8
-claudius.9 < lc1.ch0.cc9
-claudius.10 < lc1.ch0.cc10
-claudius.11 < lc1.ch0.cc11
-claudius.12 < lc1.ch0.cc12
-claudius.13 < lc1.ch0.cc13
-claudius.14 < lc1.ch0.cc14
-claudius.15 < lc1.ch0.cc15
-claudius.16 < lc1.ch0.cc16
+; Effect control
+xlaser.{1..16} < lc1.ch0.cc{1..16}
 
-; BCF Fader
-out.ch0.ch0.note< bcf1.ch0.cc81
-out.ch0.note1 < bcf1.ch0.cc82
-out.ch0.note2 < bcf1.ch0.cc83
-out.ch0.note3 < bcf1.ch0.cc84
-out.ch0.note4 < bcf1.ch0.cc85
-out.ch0.note5 < bcf1.ch0.cc86
-out.ch0.note6 < bcf1.ch0.cc87
-out.ch0.note7 < bcf1.ch0.cc88
-out.ch0.note8 < bcf2.ch0.cc81
-out.ch0.note9 < bcf2.ch0.cc82
-out.ch0.note10 < bcf2.ch0.cc83
-out.ch0.note11 < bcf2.ch0.cc84
-out.ch0.note12 < bcf2.ch0.cc85
-out.ch0.note13 < bcf2.ch0.cc86
-out.ch0.note14 < bcf2.ch0.cc87
-out.ch0.note15 < bcf2.ch0.cc88
+; BCF Faders to GrandMA
+grandma.ch0.note{0..7} < fader1.ch0.cc{81..88}
+grandma.ch0.note{8..15} < fader2.ch0.cc{81..88}
 
 ; LC Rotary
-out.ch0.note16 < lc1.ch0.cc1
-out.ch0.note17 < lc1.ch0.cc2
-out.ch0.note18 < lc1.ch0.cc3
-out.ch0.note19 < lc1.ch0.cc4
-out.ch0.note20 < lc1.ch0.cc5
-out.ch0.note21 < lc1.ch0.cc6
-out.ch0.note22 < lc1.ch0.cc7
-out.ch0.note23 < lc1.ch0.cc8
-out.ch0.note24 < lc1.ch0.cc9
-out.ch0.note25 < lc1.ch0.cc10
-out.ch0.note26 < lc1.ch0.cc11
-out.ch0.note27 < lc1.ch0.cc12
-out.ch0.note28 < lc1.ch0.cc13
-out.ch0.note29 < lc1.ch0.cc14
-out.ch0.note30 < lc1.ch0.cc15
-out.ch0.note31 < lc1.ch0.cc16
-out.ch0.note32 < lc2.ch0.cc1
-out.ch0.note33 < lc2.ch0.cc2
-out.ch0.note34 < lc2.ch0.cc3
-out.ch0.note35 < lc2.ch0.cc4
-out.ch0.note36 < lc2.ch0.cc5
-out.ch0.note37 < lc2.ch0.cc6
-out.ch0.note38 < lc2.ch0.cc7
-out.ch0.note39 < lc2.ch0.cc8
-out.ch0.note40 < lc2.ch0.cc9
-out.ch0.note41 < lc2.ch0.cc10
-out.ch0.note42 < lc2.ch0.cc11
-out.ch0.note43 < lc2.ch0.cc12
-out.ch0.note44 < lc2.ch0.cc13
-out.ch0.note45 < lc2.ch0.cc14
-out.ch0.note46 < lc2.ch0.cc15
-out.ch0.note47 < lc2.ch0.cc16
+grandma.ch0.note{16..31} < lc1.ch0.cc{1..16}
+grandma.ch0.note{32..47} < lc2.ch0.cc{1..16}
 
 ; LC Button
-out.ch0.note48 < lc1.ch0.note0
-out.ch0.note49 < lc1.ch0.note1
-out.ch0.note50 < lc1.ch0.note2
-out.ch0.note51 < lc1.ch0.note3
-out.ch0.note52 < lc1.ch0.note4
-out.ch0.note53 < lc1.ch0.note5
-out.ch0.note54 < lc1.ch0.note6
-out.ch0.note55 < lc1.ch0.note7
-
-out.ch0.note56 < lc2.ch0.note0
-out.ch0.note57 < lc2.ch0.note1
-out.ch0.note58 < lc2.ch0.note2
-out.ch0.note59 < lc2.ch0.note3
-out.ch0.note60 < lc2.ch0.note4
-out.ch0.note61 < lc2.ch0.note5
-out.ch0.note62 < lc2.ch0.note6
-out.ch0.note63 < lc2.ch0.note7
+grandma.ch0.note{48..55} < lc1.ch0.note{0..7}
+grandma.ch0.note{56..63} < lc2.ch0.note{0..7}
 
 ; Launchpad
-out.ch0.note64 < pad.ch0.note0
-out.ch0.note65 < pad.ch0.note1
-out.ch0.note66 < pad.ch0.note2
-out.ch0.note67 < pad.ch0.note3
-out.ch0.note68 < pad.ch0.note4
-out.ch0.note69 < pad.ch0.note5
-out.ch0.note70 < pad.ch0.note6
-out.ch0.note71 < pad.ch0.note7
-out.ch0.note72 < pad.ch0.note16
-out.ch0.note73 < pad.ch0.note17
-out.ch0.note74 < pad.ch0.note18
-out.ch0.note75 < pad.ch0.note19
-out.ch0.note76 < pad.ch0.note20
-out.ch0.note77 < pad.ch0.note21
-out.ch0.note78 < pad.ch0.note22
-out.ch0.note79 < pad.ch0.note23
-out.ch0.note80 < pad.ch0.note32
-out.ch0.note81 < pad.ch0.note33
-out.ch0.note82 < pad.ch0.note34
-out.ch0.note83 < pad.ch0.note35
-out.ch0.note84 < pad.ch0.note36
-out.ch0.note85 < pad.ch0.note37
-out.ch0.note86 < pad.ch0.note38
-out.ch0.note87 < pad.ch0.note39
-out.ch0.note88 < pad.ch0.note48
-out.ch0.note89 < pad.ch0.note49
-out.ch0.note90 < pad.ch0.note50
-out.ch0.note91 < pad.ch0.note51
-out.ch0.note92 < pad.ch0.note52
-out.ch0.note93 < pad.ch0.note53
-out.ch0.note94 < pad.ch0.note54
-out.ch0.note95 < pad.ch0.note55
-out.ch0.note96 < pad.ch0.note64
-out.ch0.note97 < pad.ch0.note65
-out.ch0.note98 < pad.ch0.note66
-out.ch0.note99 < pad.ch0.note67
-out.ch0.note100 < pad.ch0.note68
-out.ch0.note101 < pad.ch0.note69
-out.ch0.note102 < pad.ch0.note70
-out.ch0.note103 < pad.ch0.note71
-out.ch0.note104 < pad.ch0.note80
-out.ch0.note105 < pad.ch0.note81
-out.ch0.note106 < pad.ch0.note82
-out.ch0.note107 < pad.ch0.note83
-out.ch0.note108 < pad.ch0.note84
-out.ch0.note109 < pad.ch0.note85
-out.ch0.note110 < pad.ch0.note86
-out.ch0.note111 < pad.ch0.note87
-out.ch0.note112 < pad.ch0.note96
-out.ch0.note113 < pad.ch0.note97
-out.ch0.note114 < pad.ch0.note98
-out.ch0.note115 < pad.ch0.note99
-out.ch0.note116 < pad.ch0.note100
-out.ch0.note117 < pad.ch0.note101
-out.ch0.note118 < pad.ch0.note102
-out.ch0.note119 < pad.ch0.note103
-out.ch0.note120 < pad.ch0.note112
-out.ch0.note121 < pad.ch0.note113
-out.ch0.note122 < pad.ch0.note114
-out.ch0.note123 < pad.ch0.note115
-out.ch0.note124 < pad.ch0.note116
-out.ch0.note125 < pad.ch0.note117
-out.ch0.note126 < pad.ch0.note118
-out.ch0.note127 < pad.ch0.note119
+grandma.ch0.note{64..71} < launchpad.ch0.note{0..7}
+grandma.ch0.note{72..79} < launchpad.ch0.note{16..23}
+grandma.ch0.note{80..87} < launchpad.ch0.note{32..39}
+grandma.ch0.note{88..95} < launchpad.ch0.note{48..55}
+grandma.ch0.note{96..103} < launchpad.ch0.note{64..71}
+grandma.ch0.note{104..111} < launchpad.ch0.note{80..87}
+grandma.ch0.note{112..119} < launchpad.ch0.note{96..103}
+grandma.ch0.note{120..127} < launchpad.ch0.note{112..119}
-- 
cgit v1.2.3


From 26ee2eacc7d60aa379c9e4b9b9c6b8bcdcd4bc6b Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 27 Jul 2019 19:31:21 +0200
Subject: Refactor OSC backend, implement pattern matching

---
 README.md                 |   4 +-
 TODO                      |   1 -
 backends/Makefile         |   4 +-
 backends/osc.c            | 635 ++++++++++++++++++++++++++++++++--------------
 backends/osc.h            |  25 +-
 backends/osc.md           |  21 +-
 configs/flying-faders.cfg |  24 ++
 configs/flying-faders.lua |  10 +
 configs/osc-xy.cfg        |  26 ++
 9 files changed, 543 insertions(+), 207 deletions(-)
 create mode 100644 configs/flying-faders.cfg
 create mode 100644 configs/flying-faders.lua
 create mode 100644 configs/osc-xy.cfg

(limited to 'TODO')

diff --git a/README.md b/README.md
index 3704f5f..9647d4f 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,8 @@ Currently, the MIDIMonster supports the following protocols:
 
 * MIDI (Linux, via ALSA)
 * ArtNet
-* sACN / E1.31
-* OSC
+* Streaming ACN (sACN / E1.31)
+* OpenSoundControl (OSC)
 * evdev input devices (Linux)
 * Open Lighting Architecture (OLA)
 
diff --git a/TODO b/TODO
index d114640..2a97c30 100644
--- a/TODO
+++ b/TODO
@@ -3,6 +3,5 @@ Note source in channel value struct
 Optimize core channel search (store backend offset)
 Printing backend / Verbose mode
 
-document example configs
 evdev relative axis size
 mm_managed_fd.impl is not freed currently
diff --git a/backends/Makefile b/backends/Makefile
index fe88669..22cb95b 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -6,8 +6,8 @@ BACKEND_LIB = libmmbackend.o
 
 SYSTEM := $(shell uname -s)
 
-CFLAGS += -fPIC -I../
-CPPFLAGS += -fPIC -I../
+CFLAGS += -g -fPIC -I../
+CPPFLAGS += -g -fPIC -I../
 LDFLAGS += -shared
 
 # Build Linux backends if possible
diff --git a/backends/osc.c b/backends/osc.c
index 36b0993..3f19abf 100644
--- a/backends/osc.c
+++ b/backends/osc.c
@@ -13,6 +13,14 @@
 #define osc_align(a) ((((a) / 4) + (((a) % 4) ? 1 : 0)) * 4)
 #define BACKEND_NAME "osc"
 
+typedef union {
+	struct {
+		uint32_t channel;
+		uint32_t parameter;
+	} fields;
+	uint64_t label;
+} osc_channel_ident;
+
 static struct {
 	uint8_t detect;
 } osc_global_config = {
@@ -41,6 +49,7 @@ int init(){
 }
 
 static size_t osc_data_length(osc_parameter_type t){
+	//binary representation lengths for osc data types
 	switch(t){
 		case int32:
 		case float32:
@@ -55,6 +64,7 @@ static size_t osc_data_length(osc_parameter_type t){
 }
 
 static inline void osc_defaults(osc_parameter_type t, osc_parameter_value* max, osc_parameter_value* min){
+	//data type default ranges
 	memset(max, 0, sizeof(osc_parameter_value));
 	memset(min, 0, sizeof(osc_parameter_value));
 	switch(t){
@@ -77,6 +87,7 @@ static inline void osc_defaults(osc_parameter_type t, osc_parameter_value* max,
 }
 
 static inline osc_parameter_value osc_parse(osc_parameter_type t, uint8_t* data){
+	//read value from binary representation
 	osc_parameter_value v = {0};
 	switch(t){
 		case int32:
@@ -94,6 +105,7 @@ static inline osc_parameter_value osc_parse(osc_parameter_type t, uint8_t* data)
 }
 
 static inline int osc_deparse(osc_parameter_type t, osc_parameter_value v, uint8_t* data){
+	//write value to binary representation
 	uint64_t u64 = 0;
 	uint32_t u32 = 0;
 	switch(t){
@@ -115,6 +127,7 @@ static inline int osc_deparse(osc_parameter_type t, osc_parameter_value v, uint8
 }
 
 static inline osc_parameter_value osc_parse_value_spec(osc_parameter_type t, char* value){
+	//read value from string
 	osc_parameter_value v = {0};
 	switch(t){
 		case int32:
@@ -136,6 +149,7 @@ static inline osc_parameter_value osc_parse_value_spec(osc_parameter_type t, cha
 }
 
 static inline channel_value osc_parameter_normalise(osc_parameter_type t, osc_parameter_value min, osc_parameter_value max, osc_parameter_value cur){
+	//normalise osc value wrt given min/max
 	channel_value v = {
 		.raw = {0},
 		.normalised = 0
@@ -179,6 +193,7 @@ static inline channel_value osc_parameter_normalise(osc_parameter_type t, osc_pa
 }
 
 static inline osc_parameter_value osc_parameter_denormalise(osc_parameter_type t, osc_parameter_value min, osc_parameter_value max, channel_value cur){
+	//convert normalised value to osc value wrt given min/max
 	osc_parameter_value v = {0};
 
 	union {
@@ -212,45 +227,192 @@ static inline osc_parameter_value osc_parameter_denormalise(osc_parameter_type t
 	return v;
 }
 
-static int osc_generate_event(channel* c, osc_channel* info, char* fmt, uint8_t* data, size_t data_len){
-	size_t p, off = 0;
-	if(!c || !info){
-		return 0;
+static int osc_path_validate(char* path, uint8_t allow_patterns){
+	//validate osc path or pattern
+	char illegal_chars[] = " #,";
+	char pattern_chars[] = "?[]{}*";
+	size_t u, c;
+	uint8_t square_open = 0, curly_open = 0;
+	
+	if(path[0] != '/'){
+		fprintf(stderr, "%s is not a valid OSC path: Missing root /\n", path);
+		return 1;
 	}
 
-	osc_parameter_value min, max, cur;
-	channel_value evt;
+	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);
+				return 1;
+			}
+		}
 
-	if(!fmt || !data || data_len % 4 || !*fmt){
-		fprintf(stderr, "Invalid OSC packet, data length %zu\n", data_len);
-		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);
+			return 1;
+		}
 
-	//find offset for this parameter
-	for(p = 0; p < info->param_index; p++){
-		off += osc_data_length(fmt[p]);
-	}
+		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);
+					return 1;
+				}
+			}
+		}
 
-	if(info->type != not_set){
-		max = info->max;
-		min = info->min;
+		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);
+					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);
+					return 1;
+				}
+				square_open = 1;
+				break;
+			case '}':
+				curly_open = 0;
+				break;
+			case ']':
+				square_open = 0;
+				break;
+			case '/':
+				if(square_open || curly_open){
+					fprintf(stderr, "%s is not a valid OSC path: Pattern across part boundaries\n", path);
+					return 1;
+				}
+		}
 	}
-	else{
-		osc_defaults(fmt[info->param_index], &max, &min);
+
+	if(square_open || curly_open){
+		fprintf(stderr, "%s is not a valid OSC path: Unterminated pattern expression\n", path);
+		return 1;
 	}
+	return 0;
+}
 
-	cur = osc_parse(fmt[info->param_index], data + off);
-	evt = osc_parameter_normalise(fmt[info->param_index], min, max, cur);
+static int osc_path_match(char* pattern, char* path){
+	size_t u, p = 0, match_begin, match_end;
+	uint8_t match_any = 0, inverted, match;
 
-	return mm_channel_event(c, evt);
-}
+	for(u = 0; u < strlen(path); u++){
+		switch(pattern[p]){
+			case '/':
+				if(match_any){
+					for(; path[u] && path[u] != '/'; u++){
+					}
+				}
+				if(path[u] != '/'){
+					return 0;
+				}
+				match_any = 0;
+				p++;
+				break;
+			case '?':
+				match_any = 0;
+				p++;
+				break;
+			case '*':
+				match_any = 1;
+				p++;
+				break;
+			case '[':
+				inverted = (pattern[p + 1] == '!') ? 1 : 0;
+				match_end = match_begin = inverted ? p + 2 : p + 1;
+				match = 0;
+				for(; pattern[match_end] != ']'; match_end++){
+					if(pattern[match_end] == path[u]){
+						match = 1;
+						break;
+					}
 
-static int osc_validate_path(char* path){
-	if(path[0] != '/'){
-		fprintf(stderr, "%s is not a valid OSC path: Missing root /\n", path);
-		return 1;
+					if(pattern[match_end + 1] == '-' && pattern[match_end + 2] != ']'){
+						if((pattern[match_end] > pattern[match_end + 2] 
+									&& path[u] >= pattern[match_end + 2]
+									&& path[u] <= pattern[match_end])
+								|| (pattern[match_end] <= pattern[match_end + 2]
+									&& path[u] >= pattern[match_end]
+									&& path[u] <= pattern[match_end + 2])){
+							match = 1;
+							break;
+						}
+						match_end += 2;
+					}
+
+					if(pattern[match_end + 1] == ']' && match_any && !match
+							&& path[u + 1] && path[u + 1] != '/'){
+						match_end = match_begin - 1;
+						u++;
+					}
+				}
+
+				if(match == inverted){
+					return 0;
+				}
+
+				match_any = 0;
+				//advance to end of pattern
+				for(; pattern[p] != ']'; p++){
+				}
+				p++;
+				break;
+			case '{':
+				for(match_begin = p + 1; pattern[match_begin] != '}'; match_begin++){
+					//find end
+					for(match_end = match_begin; pattern[match_end] != ',' && pattern[match_end] != '}'; match_end++){
+					}
+
+					if(!strncmp(path + u, pattern + match_begin, match_end - match_begin)){
+						//advance pattern
+						for(; pattern[p] != '}'; p++){
+						}
+						p++;
+						//advance path
+						u += match_end - match_begin - 1;
+						break;
+					}
+
+					if(pattern[match_end] == '}'){
+						//retry with next if in match_any
+						if(match_any && path[u + 1] && path[u + 1] != '/'){
+							u++;
+							match_begin = p;
+							continue;
+						}
+						return 0;
+					}
+					match_begin = match_end;
+				}
+				match_any = 0;
+				break;
+			case 0:
+				if(match_any){
+					for(; path[u] && path[u] != '/'; u++){
+					}
+				}
+				if(path[u]){
+					return 0;
+				}
+				break;
+			default:
+				if(match_any){
+					for(; path[u] && path[u] != '/' && path[u] != pattern[p]; u++){
+					}
+				}
+				if(pattern[p] != path[u]){
+					return 0;
+				}
+				p++;
+				break;
+		}
 	}
-	return 0;
+	return 1;
 }
 
 static int osc_configure(char* option, char* value){
@@ -266,13 +428,81 @@ static int osc_configure(char* option, char* value){
 	return 1;
 }
 
+static int osc_register_pattern(osc_instance_data* data, char* pattern_path, char* configuration){
+	size_t u, pattern;
+	char* format = NULL, *token = NULL;
+
+	if(osc_path_validate(pattern_path, 1)){
+		fprintf(stderr, "Not a valid OSC pattern: %s\n", pattern_path);
+		return 1;
+	}
+
+	//tokenize configuration
+	format = strtok(configuration, " ");
+	if(!format || strlen(format) < 1){
+		fprintf(stderr, "Not a valid format specification for OSC pattern %s\n", pattern_path);
+		return 1;
+	}
+
+	//create pattern
+	data->pattern = realloc(data->pattern, (data->patterns + 1) * sizeof(osc_channel));
+	if(!data->pattern){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return 1;
+	}
+	pattern = data->patterns;
+
+	data->pattern[pattern].params = strlen(format);
+	data->pattern[pattern].path = strdup(pattern_path);
+	data->pattern[pattern].type = calloc(strlen(format), sizeof(osc_parameter_type));
+	data->pattern[pattern].max = calloc(strlen(format), sizeof(osc_parameter_value));
+	data->pattern[pattern].min = calloc(strlen(format), sizeof(osc_parameter_value));
+
+	if(!data->pattern[pattern].path
+			|| !data->pattern[pattern].type
+			|| !data->pattern[pattern].max
+			|| !data->pattern[pattern].min){
+		//this should fail config parsing and thus call the shutdown function,
+		//which should properly free the rest of the data
+		fprintf(stderr, "Failed to allocate memory\n");
+		return 1;
+	}
+
+	//check format validity and store min/max values
+	for(u = 0; u < strlen(format); u++){
+		if(!osc_data_length(format[u])){
+			fprintf(stderr, "Invalid format specifier %c for pattern %s\n", format[u], pattern_path);
+			return 1;
+		}
+
+		data->pattern[pattern].type[u] = format[u];
+
+		//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);
+			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);
+			return 1;
+		}
+		data->pattern[pattern].max[u] = osc_parse_value_spec(format[u], token);
+	}
+
+	data->patterns++;
+	return 0;
+}
+
 static int osc_configure_instance(instance* inst, char* option, char* value){
 	osc_instance_data* data = (osc_instance_data*) inst->impl;
-	char* host = NULL, *port = NULL, *token = NULL, *format = NULL;
-	size_t u, p;
+	char* host = NULL, *port = NULL, *token = NULL;
 
 	if(!strcmp(option, "root")){
-		if(osc_validate_path(value)){
+		if(osc_path_validate(value, 0)){
 			fprintf(stderr, "Not a valid OSC root: %s\n", value);
 			return 1;
 		}
@@ -326,76 +556,7 @@ static int osc_configure_instance(instance* inst, char* option, char* value){
 		return 0;
 	}
 	else if(*option == '/'){
-		//pre-configure channel
-		if(osc_validate_path(option)){
-			fprintf(stderr, "Not a valid OSC path: %s\n", option);
-			return 1;
-		}
-
-		for(u = 0; u < data->channels; u++){
-			if(!strcmp(option, data->channel[u].path)){
-				fprintf(stderr, "OSC channel %s already configured\n", option);
-				return 1;
-			}
-		}
-
-		//tokenize configuration
-		format = strtok(value, " ");
-		if(!format || strlen(format) < 1){
-			fprintf(stderr, "Not a valid format for OSC path %s\n", option);
-			return 1;
-		}
-
-		//check format validity, create subchannels
-		for(p = 0; p < strlen(format); p++){
-			if(!osc_data_length(format[p])){
-				fprintf(stderr, "Invalid format specifier %c for path %s, ignoring\n", format[p], option);
-				continue;
-			}
-
-			//register new sub-channel
-			data->channel = realloc(data->channel, (data->channels + 1) * sizeof(osc_channel));
-			if(!data->channel){
-				fprintf(stderr, "Failed to allocate memory\n");
-				return 1;
-			}
-
-			memset(data->channel + data->channels, 0, sizeof(osc_channel));
-			data->channel[data->channels].params = strlen(format);
-			data->channel[data->channels].param_index = p;
-			data->channel[data->channels].type = format[p];
-			data->channel[data->channels].path = strdup(option);
-
-			if(!data->channel[data->channels].path){
-				fprintf(stderr, "Failed to allocate memory\n");
-				return 1;
-			}
-
-			//parse min/max values
-			token = strtok(NULL, " ");
-			if(!token){
-				fprintf(stderr, "Missing minimum specification for parameter %zu of %s\n", p, option);
-				return 1;
-			}
-			data->channel[data->channels].min = osc_parse_value_spec(format[p], token);
-
-			token = strtok(NULL, " ");
-			if(!token){
-				fprintf(stderr, "Missing maximum specification for parameter %zu of %s\n", p, option);
-				return 1;
-			}
-			data->channel[data->channels].max = osc_parse_value_spec(format[p], token);
-
-			//allocate channel from core
-			if(!mm_channel(inst, data->channels, 1)){
-				fprintf(stderr, "Failed to register core channel\n");
-				return 1;
-			}
-
-			//increase channel count
-			data->channels++;
-		}
-		return 0;
+		return osc_register_pattern(data, option, value);
 	}
 
 	fprintf(stderr, "Unknown configuration parameter %s for OSC instance %s\n", option, inst->name);
@@ -420,31 +581,38 @@ static instance* osc_instance(){
 }
 
 static channel* osc_map_channel(instance* inst, char* spec){
-	size_t u;
+	size_t u, p;
 	osc_instance_data* data = (osc_instance_data*) inst->impl;
-	size_t param_index = 0;
+	osc_channel_ident ident = {
+		.label = 0
+	};
 
 	//check spec for correctness
-	if(osc_validate_path(spec)){
+	if(osc_path_validate(spec, 0)){
 		return NULL;
 	}
 
 	//parse parameter offset
 	if(strrchr(spec, ':')){
-		param_index = strtoul(strrchr(spec, ':') + 1, NULL, 10);
+		ident.fields.parameter = strtoul(strrchr(spec, ':') + 1, NULL, 10);
 		*(strrchr(spec, ':')) = 0;
 	}
 
 	//find matching channel
 	for(u = 0; u < data->channels; u++){
-		if(!strcmp(spec, data->channel[u].path) && data->channel[u].param_index == param_index){
-			//fprintf(stderr, "Reusing previously created channel %s parameter %zu\n", data->channel[u].path, data->channel[u].param_index);
+		if(!strcmp(spec, data->channel[u].path)){
 			break;
 		}
 	}
 
 	//allocate new channel
 	if(u == data->channels){
+		for(p = 0; p < data->patterns; p++){
+			if(osc_path_match(data->pattern[p].path, spec)){
+				break;
+			}
+		}
+
 		data->channel = realloc(data->channel, (u + 1) * sizeof(osc_channel));
 		if(!data->channel){
 			fprintf(stderr, "Failed to allocate memory\n");
@@ -452,22 +620,100 @@ static channel* osc_map_channel(instance* inst, char* spec){
 		}
 
 		memset(data->channel + u, 0, sizeof(osc_channel));
-		data->channel[u].param_index = param_index;
 		data->channel[u].path = strdup(spec);
+		if(p != data->patterns){
+			fprintf(stderr, "Matched pattern %s for %s\n", data->pattern[p].path, spec);
+			data->channel[u].params = data->pattern[p].params;
+			//just reuse the pointers from the pattern
+			data->channel[u].type = data->pattern[p].type;
+			data->channel[u].max = data->pattern[p].max;
+			data->channel[u].min = data->pattern[p].min;
+
+			//these are per channel
+			data->channel[u].in = calloc(data->channel[u].params, sizeof(osc_parameter_value));
+			data->channel[u].out = calloc(data->channel[u].params, sizeof(osc_parameter_value));
+		}
+		else if(data->patterns){
+			fprintf(stderr, "No pattern match found for %s\n", spec);
+		}
 
-		if(!data->channel[u].path){
+		if(!data->channel[u].path
+				|| (data->channel[u].params && (!data->channel[u].in || !data->channel[u].out))){
 			fprintf(stderr, "Failed to allocate memory\n");
 			return NULL;
 		}
 		data->channels++;
 	}
 
-	return mm_channel(inst, u, 1);
+	ident.fields.channel = u;
+	return mm_channel(inst, ident.label, 1);
+}
+
+static int osc_output_channel(instance* inst, size_t channel){
+	osc_instance_data* data = (osc_instance_data*) inst->impl;
+	uint8_t xmit_buf[OSC_XMIT_BUF] = "", *format = NULL;
+	size_t offset = 0, p;
+
+	//fix destination rport if required
+	if(data->forced_rport){
+		//cheating a bit because both IPv4 and IPv6 have the port at the same offset
+		struct sockaddr_in* sockadd = (struct sockaddr_in*) &(data->dest);
+		sockadd->sin_port = htobe16(data->forced_rport);
+	}
+
+	//determine minimum packet size
+	if(osc_align((data->root ? strlen(data->root) : 0) + strlen(data->channel[channel].path) + 1) + osc_align(data->channel[channel].params + 2)  >= sizeof(xmit_buf)){
+		fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s\n", inst->name, data->channel[channel].path);
+		return 1;
+	}
+
+	//copy osc target path
+	if(data->root){
+		memcpy(xmit_buf, data->root, strlen(data->root));
+		offset += strlen(data->root);
+	}
+	
+	memcpy(xmit_buf + offset, data->channel[channel].path, strlen(data->channel[channel].path));
+	offset += strlen(data->channel[channel].path) + 1;
+	offset = osc_align(offset);
+
+	//get format string offset, initialize
+	format = xmit_buf + offset;
+	offset += osc_align(data->channel[channel].params + 2);
+	*format = ',';
+	format++;
+
+	for(p = 0; p < data->channel[channel].params; p++){
+		//write format specifier
+		format[p] = data->channel[channel].type[p];
+
+		//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);
+			return 1;
+		}
+
+		osc_deparse(data->channel[channel].type[p],
+				data->channel[channel].out[p],
+				xmit_buf + offset);
+		offset += osc_data_length(data->channel[channel].type[p]);
+	}
+
+	//output packet
+	if(sendto(data->fd, xmit_buf, offset, 0, (struct sockaddr*) &(data->dest), data->dest_len) < 0){
+		fprintf(stderr, "Failed to transmit OSC packet: %s\n", strerror(errno));
+	}
+	return 0;
 }
 
 static int osc_set(instance* inst, size_t num, channel** c, channel_value* v){
-	uint8_t xmit_buf[OSC_XMIT_BUF], *format = NULL;
-	size_t evt = 0, off, members, p;
+	size_t evt = 0, mark = 0;
+	int rv;
+	osc_channel_ident ident = {
+		.label = 0
+	};
+	osc_parameter_value current;
+
 	if(!num){
 		return 0;
 	}
@@ -479,95 +725,97 @@ static int osc_set(instance* inst, size_t num, channel** c, channel_value* v){
 	}
 
 	for(evt = 0; evt < num; evt++){
-		off = c[evt]->ident;
+		ident.label = c[evt]->ident;
 
 		//sanity check
-		if(off >= data->channels){
+		if(ident.fields.channel >= data->channels
+				|| ident.fields.parameter >= data->channel[ident.fields.channel].params){
 			fprintf(stderr, "OSC channel identifier out of range\n");
 			return 1;
 		}
 
 		//if the format is unknown, don't output
-		if(data->channel[off].type == not_set || data->channel[off].params == 0){
-			fprintf(stderr, "OSC channel %s.%s requires format specification for output\n", inst->name, data->channel[off].path);
+		if(!data->channel[ident.fields.channel].params){
+			fprintf(stderr, "OSC channel %s.%s requires format specification for output\n", inst->name, data->channel[ident.fields.channel].path);
 			continue;
 		}
 
-		//update current value
-		data->channel[off].current = osc_parameter_denormalise(data->channel[off].type, data->channel[off].min, data->channel[off].max, v[evt]);
-		//mark channel
-		data->channel[off].mark = 1;
+		//only output on change
+		current = osc_parameter_denormalise(data->channel[ident.fields.channel].type[ident.fields.parameter],
+				data->channel[ident.fields.channel].min[ident.fields.parameter],
+				data->channel[ident.fields.channel].max[ident.fields.parameter],
+				v[evt]);
+		if(memcmp(&current, &data->channel[ident.fields.channel].out[ident.fields.parameter], sizeof(current))){
+			//update current value
+			data->channel[ident.fields.channel].out[ident.fields.parameter] = current;
+			//mark channel
+			data->channel[ident.fields.channel].mark = 1;
+			mark = 1;
+		}
 	}
-
-	//fix destination rport if required
-	if(data->forced_rport){
-		//cheating a bit because both IPv4 and IPv6 have the port at the same offset
-		struct sockaddr_in* sockadd = (struct sockaddr_in*) &(data->dest);
-		sockadd->sin_port = htobe16(data->forced_rport);
+	
+	if(mark){
+		//output all marked channels
+		for(evt = 0; !rv && evt < num; evt++){
+			ident.label = c[evt]->ident;
+			if(data->channel[ident.fields.channel].mark){
+				rv |= osc_output_channel(inst, ident.fields.channel);
+				data->channel[ident.fields.channel].mark = 0;
+			}
+		}
 	}
+	return rv;
+}
 
-	//find all marked channels
-	for(evt = 0; evt < data->channels; evt++){
-		//zero output buffer
-		memset(xmit_buf, 0, sizeof(xmit_buf));
-		if(data->channel[evt].mark){
-			//determine minimum packet size
-			if(osc_align((data->root ? strlen(data->root) : 0) + strlen(data->channel[evt].path) + 1) + osc_align(data->channel[evt].params + 2)  >= sizeof(xmit_buf)){
-				fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s\n", inst->name, data->channel[evt].path);
-				return 1;
-			}
+static int osc_process_packet(instance* inst, char* local_path, char* format, uint8_t* payload, size_t payload_len){
+	osc_instance_data* data = (osc_instance_data*) inst->impl;
+	size_t c, p, offset = 0;
+	osc_parameter_value min, max, cur;
+	channel_value evt;
+	osc_channel_ident ident = {
+		.label = 0
+	};
+	channel* chan = NULL;
 
-			off = 0;
-			//copy osc target path
-			if(data->root){
-				memcpy(xmit_buf, data->root, strlen(data->root));
-				off += strlen(data->root);
-			}
-			memcpy(xmit_buf + off, data->channel[evt].path, strlen(data->channel[evt].path));
-			off += strlen(data->channel[evt].path) + 1;
-			off = osc_align(off);
-
-			//get format string offset, initialize
-			format = xmit_buf + off;
-			off += osc_align(data->channel[evt].params + 2);
-			*format = ',';
-			format++;
-
-			//gather subchannels, unmark
-			members = 0;
-			for(p = 0; p < data->channels && members < data->channel[evt].params; p++){
-				if(!strcmp(data->channel[evt].path, data->channel[p].path)){
-					//unmark channel
-					data->channel[p].mark = 0;
-
-					//sanity check
-					if(data->channel[p].param_index >= data->channel[evt].params){
-						fprintf(stderr, "OSC channel %s.%s has multiple parameter offset definitions\n", inst->name, data->channel[evt].path);
-						return 1;
-					}
+	if(payload_len % 4){
+		fprintf(stderr, "Invalid OSC packet, data length %zu\n", payload_len);
+		return 0;
+	}
 
-					//write format specifier
-					format[data->channel[p].param_index] = data->channel[p].type;
+	for(c = 0; c < data->channels; c++){
+		if(!strcmp(local_path, data->channel[c].path)){
+			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);
+				continue;
+			}
 
-					//write data
-					//FIXME this currently depends on all channels being registered in the correct order, since it just appends data
-					if(off + osc_data_length(data->channel[p].type) >= sizeof(xmit_buf)){
-						fprintf(stderr, "Insufficient buffer size for OSC transmitting channel %s.%s at parameter %zu\n", inst->name, data->channel[evt].path, members);
-						return 1;
+			for(p = 0; p < strlen(format); p++){
+				ident.fields.parameter = p;
+				if(data->channel[c].params){
+					max = data->channel[c].max[p];
+					min = data->channel[c].min[p];
+				}
+				else{
+					osc_defaults(format[p], &max, &min);
+				}
+				cur = osc_parse(format[p], payload + offset);
+				if(!data->channel[c].params || memcmp(&cur, &data->channel[c].in, sizeof(cur))){
+					evt = osc_parameter_normalise(format[p], min, max, cur);
+					chan = mm_channel(inst, ident.label, 0);
+					if(chan){
+						mm_channel_event(chan, evt);
 					}
-
-					osc_deparse(data->channel[p].type, data->channel[p].current, xmit_buf + off);
-					off += osc_data_length(data->channel[p].type);
-					members++;
 				}
-			}
 
-			//output packet
-			if(sendto(data->fd, xmit_buf, off, 0, (struct sockaddr*) &(data->dest), data->dest_len) < 0){
-				fprintf(stderr, "Failed to transmit OSC packet: %s\n", strerror(errno));
+				//skip to next parameter data
+				offset += osc_data_length(format[p]);
+				//TODO check offset against payload length
 			}
 		}
 	}
+
 	return 0;
 }
 
@@ -577,7 +825,6 @@ static int osc_handle(size_t num, managed_fd* fds){
 	instance* inst = NULL;
 	osc_instance_data* data = NULL;
 	ssize_t bytes_read = 0;
-	size_t c;
 	char* osc_fmt = NULL;
 	char* osc_local = NULL;
 	uint8_t* osc_data = NULL;
@@ -600,7 +847,7 @@ static int osc_handle(size_t num, managed_fd* fds){
 				bytes_read = recv(fds[fd].fd, recv_buf, sizeof(recv_buf), 0);
 			}
 
-			if(bytes_read < 0){
+			if(bytes_read <= 0){
 				break;
 			}
 
@@ -622,20 +869,11 @@ static int osc_handle(size_t num, managed_fd* fds){
 				fprintf(stderr, "Incoming OSC data: Path %s.%s Format %s\n", inst->name, osc_local, osc_fmt);
 			}
 
-			osc_data = (uint8_t*) osc_fmt + (osc_align(strlen(osc_fmt) + 2) - 1);
 			//FIXME check supplied data length
+			osc_data = (uint8_t*) osc_fmt + (osc_align(strlen(osc_fmt) + 2) - 1);
 
-			for(c = 0; c < data->channels; c++){
-				//FIXME implement proper OSC path match
-				//prefix match
-				if(!strcmp(osc_local, data->channel[c].path)){
-					if(strlen(osc_fmt) > data->channel[c].param_index){
-						//fprintf(stderr, "Taking parameter %zu of %s (%s), %zd bytes, data offset %zu\n", data->channel[c].param_index, recv_buf, osc_fmt, bytes_read, (osc_data - (uint8_t*)recv_buf));
-						if(osc_generate_event(mm_channel(inst, c, 0), data->channel + c, osc_fmt, osc_data, bytes_read - (osc_data - (uint8_t*) recv_buf))){
-							fprintf(stderr, "Failed to generate OSC channel event\n");
-						}
-					}
-				}
+			if(osc_process_packet(inst, osc_local, osc_fmt, osc_data, bytes_read - (osc_data - (uint8_t*) recv_buf))){
+				return 1;
 			}
 		} while(bytes_read > 0);
 
@@ -706,14 +944,25 @@ static int osc_shutdown(){
 		data = (osc_instance_data*) inst[u]->impl;
 		for(c = 0; c < data->channels; c++){
 			free(data->channel[c].path);
+			free(data->channel[c].in);
+			free(data->channel[c].out);
 		}
 		free(data->channel);
+		for(c = 0; c < data->patterns; c++){
+			free(data->pattern[c].path);
+			free(data->pattern[c].type);
+			free(data->pattern[c].min);
+			free(data->pattern[c].max);
+		}
+		free(data->pattern);
+
 		free(data->root);
 		if(data->fd >= 0){
 			close(data->fd);
 		}
 		data->fd = -1;
 		data->channels = 0;
+		data->patterns = 0;
 		free(inst[u]->impl);
 	}
 
diff --git a/backends/osc.h b/backends/osc.h
index dc6cb3a..4e9dec5 100644
--- a/backends/osc.h
+++ b/backends/osc.h
@@ -34,22 +34,33 @@ typedef union {
 typedef struct /*_osc_channel*/ {
 	char* path;
 	size_t params;
-	size_t param_index;
 	uint8_t mark;
 
-	osc_parameter_type type;
-	osc_parameter_value max;
-	osc_parameter_value min;
-	osc_parameter_value current;
+	osc_parameter_type* type;
+	osc_parameter_value* max;
+	osc_parameter_value* min;
+	osc_parameter_value* in;
+	osc_parameter_value* out;
 } osc_channel;
 
 typedef struct /*_osc_instance_data*/ {
+	//pre-configured channel patterns
+	size_t patterns;
+	osc_channel* pattern;
+
+	//actual channel registry
 	size_t channels;
 	osc_channel* channel;
+
+	//instance config
 	char* root;
+	uint8_t learn;
+
+	//peer addressing
 	socklen_t dest_len;
 	struct sockaddr_storage dest;
-	int fd;
-	uint8_t learn;
 	uint16_t forced_rport;
+
+	//peer fd
+	int fd;
 } osc_instance_data;
diff --git a/backends/osc.md b/backends/osc.md
index e9aa4d5..b7ce527 100644
--- a/backends/osc.md
+++ b/backends/osc.md
@@ -23,13 +23,21 @@ it are ignored early in processing.
 Channels that are to be output or require a value range different from the default ranges (see below)
 require special configuration, as their types and limits have to be set.
 
-This is done in the instance configuration using an assignment of the syntax
+This is done by specifying *patterns* in the instance configuration using an assignment of the syntax
 
 ```
 /local/osc/path = <format> <min> <max> <min> <max> ...
 ```
 
-The OSC path to be configured must only be the local part (omitting a configured instance root).
+The pattern will be matched only against the local part (that is, the path excluding any configured instance root).
+Patterns may contain the following expressions (conforming to the [OSC pattern matching specification](http://opensoundcontrol.org/spec-1_0)):
+* `?` matches any single legal character
+* `*` matches zero or more legal characters
+* A comma-separated list of strings inside curly braces `{}` matches any of the strings
+* A string of characters within square brackets `[]` matches any character in the string
+	* Two characters with a `-` between them specify a range of characters
+	* An exclamation mark immediately after the opening `[` negates the meaning of the expression (ie. it matches characters not in the range)
+* Any other legal character matches only itself
 
 **format** may be any sequence of valid OSC type characters. See below for a table of supported
 OSC types.
@@ -44,6 +52,12 @@ a range between 0.0 and 2.0 (for example, an X-Y control), would look as follows
 /1/xy1 = ff 0.0 2.0 0.0 2.0
 ```
 
+To configure a range of faders, an expression similar to the following line could be used
+
+```
+/1/fader* = f 0.0 1.0
+```
+
 #### Channel specification
 
 A channel may be any valid OSC path, to which the instance root will be prepended if
@@ -80,4 +94,7 @@ The default ranges are:
 
 #### Known bugs / problems
 
+The OSC path match currently works on the unit of characters. This may lead to some unexpected results
+when matching expressions of the form `*<expr>`.
+
 Ping requests are not yet answered. There may be some problems using broadcast output and input.
diff --git a/configs/flying-faders.cfg b/configs/flying-faders.cfg
new file mode 100644
index 0000000..4197581
--- /dev/null
+++ b/configs/flying-faders.cfg
@@ -0,0 +1,24 @@
+; Create a 'flying faders' effect using lua and output
+; it onto TouchOSC (Layout 'Mix16', Multifader view on page 4)
+
+[osc touch]
+bind = * 8000
+dest = learn@9000
+
+; Pre-declare the fader values so the range mapping is correct
+/*/fader* = f 0.0 1.0
+/*/toggle* = f 0.0 1.0
+/*/push* = f 0.0 1.0
+/*/multifader*/* = f 0.0 1.0
+/1/xy = ff 0.0 1.0 0.0 1.0
+
+[lua generator]
+script = configs/flying-faders.lua
+
+[map]
+
+generator.wave{1..24} > touch./4/multifader1/{1..24}
+;generator.wave{1..24} > touch./4/multifader2/{1..24}
+
+touch./4/multifader2/1 > generator.magnitude
+
diff --git a/configs/flying-faders.lua b/configs/flying-faders.lua
new file mode 100644
index 0000000..0b0faef
--- /dev/null
+++ b/configs/flying-faders.lua
@@ -0,0 +1,10 @@
+step = 0
+
+function wave()
+	for chan=1,24 do
+		output("wave" .. chan, (math.sin(math.rad((step + chan * 360 / 24) % 360)) + 1) / 2)
+	end
+	step = (step + 5) % 360
+end
+
+interval(wave, 100)
diff --git a/configs/osc-xy.cfg b/configs/osc-xy.cfg
new file mode 100644
index 0000000..fc5c5f3
--- /dev/null
+++ b/configs/osc-xy.cfg
@@ -0,0 +1,26 @@
+; Test for bi-directional OSC with an XY pad (TouchOSC Layout 'Mix16', Page 1)
+
+[backend osc]
+detect = on
+
+[osc touch]
+bind = 0.0.0.0 8000
+dest = learn@9000
+
+; Pre-declare the fader values so the range mapping is correct
+/*/xy = ff 0.0 1.0 0.0 1.0
+
+[evdev xbox]
+device = /dev/input/event16
+
+[midi launch]
+
+[map]
+xbox.EV_ABS.ABS_X > touch./1/xy:1
+xbox.EV_ABS.ABS_Y > touch./1/xy:0
+
+xbox.EV_ABS.ABS_X > launch.ch0.note2
+;xbox.EV_ABS.ABS_Y > launch.ch0.note3
+
+launch.ch0.note0 <> touch./1/xy:0
+launch.ch0.note1 <> touch./1/xy:1
-- 
cgit v1.2.3


From 4e604b493e0dc855b6ea6978e5cf8e2de5d2b8d5 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 28 Jul 2019 23:40:40 +0200
Subject: Fix evdev relative axes, add detect option

---
 TODO              |  1 -
 backends/evdev.c  | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++-----
 backends/evdev.h  |  8 ++++++++
 backends/evdev.md | 18 ++++++++++++------
 monster.cfg       |  4 +++-
 5 files changed, 75 insertions(+), 13 deletions(-)

(limited to 'TODO')

diff --git a/TODO b/TODO
index 2a97c30..5f4ce91 100644
--- a/TODO
+++ b/TODO
@@ -3,5 +3,4 @@ Note source in channel value struct
 Optimize core channel search (store backend offset)
 Printing backend / Verbose mode
 
-evdev relative axis size
 mm_managed_fd.impl is not freed currently
diff --git a/backends/evdev.c b/backends/evdev.c
index ca8469a..565eb17 100644
--- a/backends/evdev.c
+++ b/backends/evdev.c
@@ -27,6 +27,12 @@ typedef union {
 	uint64_t label;
 } evdev_channel_ident;
 
+static struct {
+	uint8_t detect;
+} evdev_config = {
+	.detect = 0
+};
+
 int init(){
 	backend evdev = {
 		.name = BACKEND_NAME,
@@ -49,7 +55,15 @@ int init(){
 }
 
 static int evdev_configure(char* option, char* value) {
-	fprintf(stderr, "The evdev backend does not take any global configuration\n");
+	if(!strcmp(option, "detect")){
+		evdev_config.detect = 1;
+		if(!strcmp(value, "off")){
+			evdev_config.detect = 0;
+		}
+		return 0;
+	}
+
+	fprintf(stderr, "Unknown configuration option %s for evdev backend\n", option);
 	return 1;
 }
 
@@ -185,6 +199,22 @@ static int evdev_configure_instance(instance* inst, char* option, char* value) {
 		data->exclusive = 1;
 		return 0;
 	}
+	else if(!strncmp(option, "relaxis.", 8)){
+		data->relative_axis = realloc(data->relative_axis, (data->relative_axes + 1) * sizeof(evdev_relaxis_config));
+		if(!data->relative_axis){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return 1;
+		}
+		data->relative_axis[data->relative_axes].code = libevdev_event_code_from_name(EV_REL, option + 8);
+		data->relative_axis[data->relative_axes].max = strtoul(value, &next_token, 0);
+		data->relative_axis[data->relative_axes].current = strtoul(next_token, NULL, 0);
+		if(data->relative_axis[data->relative_axes].code < 0){
+			fprintf(stderr, "Failed to configure relative axis extents for %s.%s\n", inst->name, option + 8);
+			return 1;
+		}
+		data->relative_axes++;
+		return 0;
+	}
 #ifndef EVDEV_NO_UINPUT
 	else if(!strcmp(option, "output")){
 		data->output_enabled = 1;
@@ -214,7 +244,7 @@ static int evdev_configure_instance(instance* inst, char* option, char* value) {
 		return 0;
 	}
 #endif
-	fprintf(stderr, "Unknown configuration parameter %s for evdev backend\n", option);
+	fprintf(stderr, "Unknown instance configuration parameter %s for evdev instance %s\n", option, inst->name);
 	return 1;
 }
 
@@ -275,21 +305,32 @@ static int evdev_push_event(instance* inst, evdev_instance_data* data, struct in
 		.fields.code = event.code
 	};
 	channel* chan = mm_channel(inst, ident.label, 0);
+	size_t axis;
 
 	if(chan){
 		val.raw.u64 = event.value;
 		switch(event.type){
 			case EV_REL:
-				val.normalised = 0.5 + ((event.value < 0) ? 0.5 : -0.5);
+				for(axis = 0; axis < data->relative_axes; axis++){
+					if(data->relative_axis[axis].code == event.code){
+						data->relative_axis[axis].current = clamp(data->relative_axis[axis].current + event.value, data->relative_axis[axis].max, 0);
+						val.normalised = (double) data->relative_axis[axis].current / (double) data->relative_axis[axis].max;
+						break;
+					}
+				}
+				if(axis == data->relative_axes){
+					val.normalised = 0.5 + ((event.value < 0) ? 0.5 : -0.5);
+					break;
+				}
 				break;
 			case EV_ABS:
 				range = libevdev_get_abs_maximum(data->input_ev, event.code) - libevdev_get_abs_minimum(data->input_ev, event.code);
-				val.normalised = (event.value - libevdev_get_abs_minimum(data->input_ev, event.code)) / (double) range;
+				val.normalised = clamp((event.value - libevdev_get_abs_minimum(data->input_ev, event.code)) / (double) range, 1.0, 0.0);
 				break;
 			case EV_KEY:
 			case EV_SW:
 			default:
-				val.normalised = 1.0 * event.value;
+				val.normalised = clamp(1.0 * event.value, 1.0, 0.0);
 				break;
 		}
 
@@ -299,6 +340,10 @@ static int evdev_push_event(instance* inst, evdev_instance_data* data, struct in
 		}
 	}
 
+	if(evdev_config.detect){
+		fprintf(stderr, "Incoming evdev data for channel %s.%s.%s\n", inst->name, libevdev_event_type_get_name(event.type), libevdev_event_code_get_name(event.type, event.code));
+	}
+
 	return 0;
 }
 
@@ -470,6 +515,8 @@ static int evdev_shutdown(){
 
 		libevdev_free(data->output_proto);
 #endif
+		data->relative_axes = 0;
+		free(data->relative_axis);
 		free(data);
 	}
 
diff --git a/backends/evdev.h b/backends/evdev.h
index c6e3a25..d719631 100644
--- a/backends/evdev.h
+++ b/backends/evdev.h
@@ -24,10 +24,18 @@ static int evdev_shutdown();
 	#define UINPUT_MAX_NAME_SIZE 512
 #endif
 
+typedef struct /*_evdev_relative_axis_config*/ {
+	int code;
+	int64_t max;
+	int64_t current;
+} evdev_relaxis_config;
+
 typedef struct /*_evdev_instance_model*/ {
 	int input_fd;
 	struct libevdev* input_ev;
 	int exclusive;
+	size_t relative_axes;
+	evdev_relaxis_config* relative_axis;
 
 	int output_enabled;
 #ifndef EVDEV_NO_UINPUT
diff --git a/backends/evdev.md b/backends/evdev.md
index d750f1e..995b44c 100644
--- a/backends/evdev.md
+++ b/backends/evdev.md
@@ -7,7 +7,9 @@ This functionality may require elevated privileges (such as special group member
 
 #### Global configuration
 
-This backend does not take any global configuration.
+| Option        | Example value         | Default value         | Description           |
+|---------------|-----------------------|-----------------------|-----------------------|
+| `detect`      | `on`                  | `off`                 | Output the channel specification for all events coming in on configured instances to help with configuration. |
 
 #### Instance configuration
 
@@ -18,7 +20,8 @@ This backend does not take any global configuration.
 | `output`	| `My Input Device`	| none		| Output device presentation name. Setting this option enables the instance for output	|
 | `exclusive`	| `1`			| `0`		| Prevent other processes from using the device		|
 | `id`		| `0x1 0x2 0x3`		| none		| Set output device bus identification (Vendor, Product and Version), optional |
-| `axis.AXISNAME`| `34300 0 65536 255 4095` | none	| Specify absolute axis details (see below) for output. This is required for any absolute axis to be output.
+| `axis.AXISNAME`| `34300 0 65536 255 4095` | none	| Specify absolute axis details (see below) for output. This is required for any absolute axis to be output. | 
+| `relaxis.AXISNAME`| `65534 32767` | none	| Specify relative axis details (extent and optional initial value) for output and input (see below). |
 
 The absolute axis details configuration (e.g. `axis.ABS_X`) is required for any absolute axis on output-enabled
 instances. The configuration value contains, space-separated, the following values:
@@ -34,6 +37,13 @@ If an axis is not used for output, this configuration can be omitted.
 
 For real devices, all of these parameters for every axis can be found by running `evtest` on the device.
 
+To use the input from relative axes in absolute-value based protocols, the backend needs a reference frame to
+convert the relative movements to absolute values.
+
+If relative axes are used without specifying their extents, the channel will generate normalized values
+of `0`, `0.5` and `1` for any input less than, equal to and greater than `0`, respectively. As for output, only
+the values `-1`, `0` and `1` are generated for the same interval.
+
 #### Channel specification
 
 A channel is specified by its event type and event code, separated by `.`. For a complete list of event types and codes
@@ -64,10 +74,6 @@ Input devices may synchronize logically connected event types (for example, X an
 events. The MIDIMonster also generates these events after processing channel events, but may not keep the original
 event grouping.
 
-Relative axes (`EV_REL`-type events), such as generated by mouses, are currently handled in a very basic fashion,
-generating only the normalized channel values of `0`, `0.5` and `1` for any input less than, equal to and greater
-than `0`, respectively. As for output, only the values `-1`, `0` and `1` are generated for the same interval.
-
 `EV_KEY` key-down events are sent for normalized channel values over `0.9`.
 
 Extended event type values such as `EV_LED`, `EV_SND`, etc are recognized in the MIDIMonster configuration file
diff --git a/monster.cfg b/monster.cfg
index 7db3ec3..2e6f76f 100644
--- a/monster.cfg
+++ b/monster.cfg
@@ -1,6 +1,8 @@
 [backend artnet]
 bind = 0.0.0.0
 
+[backend evdev]
+
 [artnet art]
 universe = 0
 dest = 255.255.255.255
@@ -11,6 +13,6 @@ 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.{500..599} > loop.test{500..599}
-- 
cgit v1.2.3


From bb6111986bf7a997055287b916d0822957c5d13c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 11 Aug 2019 20:29:17 +0200
Subject: Initial maweb backend

---
 README.md               |   1 +
 TODO                    |   6 +
 backends/Makefile       |   2 +
 backends/libmmbackend.c | 217 +++++++++++++++
 backends/libmmbackend.h |  75 ++++++
 backends/maweb.c        | 695 ++++++++++++++++++++++++++++++++++++++++++++++++
 backends/maweb.h        |  69 +++++
 backends/maweb.md       | 142 ++++++++++
 midimonster.c           |   3 +
 monster.cfg             |  29 +-
 10 files changed, 1238 insertions(+), 1 deletion(-)
 create mode 100644 backends/maweb.c
 create mode 100644 backends/maweb.h
 create mode 100644 backends/maweb.md

(limited to 'TODO')

diff --git a/README.md b/README.md
index 8a0d7f9..3e9bb88 100644
--- a/README.md
+++ b/README.md
@@ -137,6 +137,7 @@ support for the protocols to translate.
 * `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)
+* `libssl-dev` (for the MA Web Remote backend)
 * A C compiler
 * GNUmake
 
diff --git a/TODO b/TODO
index 5f4ce91..d04773b 100644
--- a/TODO
+++ b/TODO
@@ -1,6 +1,12 @@
 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
+
+rtpmidi mode=peer
+	mode=initiator
diff --git a/backends/Makefile b/backends/Makefile
index 2635ddc..582655c 100644
--- a/backends/Makefile
+++ b/backends/Makefile
@@ -33,8 +33,10 @@ sacn.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
 sacn.dll: LDLIBS += -lws2_32
 
 maweb.so: ADDITIONAL_OBJS += $(BACKEND_LIB)
+maweb.so: LDLIBS = -lssl
 maweb.dll: ADDITIONAL_OBJS += $(BACKEND_LIB)
 maweb.dll: LDLIBS += -lws2_32
+maweb.dll: CFLAGS += -DMAWEB_NO_LIBSSL
 
 midi.so: LDLIBS = -lasound
 evdev.so: CFLAGS += $(shell pkg-config --cflags libevdev)
diff --git a/backends/libmmbackend.c b/backends/libmmbackend.c
index 2fd3b8b..c98cfe3 100644
--- a/backends/libmmbackend.c
+++ b/backends/libmmbackend.c
@@ -151,3 +151,220 @@ int mmbackend_send(int fd, uint8_t* data, size_t length){
 int mmbackend_send_str(int fd, char* data){
 	return mmbackend_send(fd, (uint8_t*) data, strlen(data));
 }
+
+json_type json_identify(char* json, size_t length){
+	size_t n;
+
+	//skip leading blanks
+	for(n = 0; json[n] && n < length && isspace(json[n]); n++){
+	}
+
+	if(n == length){
+		return JSON_INVALID;
+	}
+
+	switch(json[n]){
+		case '{':
+			return JSON_OBJECT;
+		case '[':
+			return JSON_ARRAY;
+		case '"':
+			return JSON_STRING;
+		case '-':
+		case '+':
+			return JSON_NUMBER;
+		default:
+			//true false null number
+			if(!strncmp(json + n, "true", 4)
+					|| !strncmp(json + n, "false", 5)){
+				return JSON_BOOL;
+			}
+			else if(!strncmp(json + n, "null", 4)){
+				return JSON_NULL;
+			}
+			//a bit simplistic but it should do
+			if(isdigit(json[n])){
+				return JSON_NUMBER;
+			}
+	}
+	return JSON_INVALID;
+}
+
+size_t json_validate(char* json, size_t length){
+	switch(json_identify(json, length)){
+		case JSON_STRING:
+			return json_validate_string(json, length);
+		case JSON_ARRAY:
+			return json_validate_array(json, length);
+		case JSON_OBJECT:
+			return json_validate_object(json, length);
+		case JSON_INVALID:
+			return 0;
+		default:
+			return json_validate_value(json, length);
+	}
+}
+
+size_t json_validate_string(char* json, size_t length){
+	size_t string_length = 0, offset;
+
+	for(offset = 0; json[offset] && offset < length && json[offset] != '"'; offset++){
+	}
+
+	if(offset == length){
+		return 0;
+	}
+
+	//find terminating quotation mark not preceded by escape
+	for(string_length = 1; offset + string_length < length
+			&& isprint(json[offset + string_length])
+			&& (json[offset + string_length] != '"' || json[offset + string_length - 1] == '\\'); string_length++){
+	}
+
+	//complete string found
+	if(json[offset + string_length] == '"' && json[offset + string_length - 1] != '\\'){
+		return offset + string_length + 1;
+	}
+
+	return 0;
+}
+
+size_t json_validate_array(char* json, size_t length){
+	//TODO
+	return 0;
+}
+
+size_t json_validate_object(char* json, size_t length){
+	//TODO
+	return 0;
+}
+
+size_t json_validate_value(char* json, size_t length){
+	//TODO
+	return 0;
+}
+
+size_t json_obj_offset(char* json, char* key){
+	size_t offset = 0;
+	uint8_t match = 0;
+
+	//skip whitespace
+	for(offset = 0; json[offset] && isspace(json[offset]); offset++){
+	}
+
+	if(json[offset] != '{'){
+		return 0;
+	}
+	offset++;
+
+	while(json_identify(json + offset, strlen(json + offset)) == JSON_STRING){
+		//skip to key begin
+		for(; json[offset] && json[offset] != '"'; offset++){
+		}
+
+		if(!strncmp(json + offset + 1, key, strlen(key)) && json[offset + 1 + strlen(key)] == '"'){
+			//key found
+			match = 1;
+		}
+
+		offset += json_validate_string(json + offset, strlen(json + offset));
+
+		//skip to value separator
+		for(; json[offset] && json[offset] != ':'; offset++){
+		}
+
+		//skip whitespace
+		for(offset++; json[offset] && isspace(json[offset]); offset++){
+		}
+
+		if(match){
+			return offset;
+		}
+
+		//add length of value
+		offset += json_validate(json + offset, strlen(json + offset));
+
+		//find comma or closing brace
+		for(; json[offset] && json[offset] != ',' && json[offset] != '}'; offset++){
+		}
+
+		if(json[offset] == ','){
+			offset++;
+		}
+	}
+
+	return 0;
+}
+
+json_type json_obj(char* json, char* key){
+	size_t offset = json_obj_offset(json, key);
+	if(offset){
+		return json_identify(json + offset, strlen(json + offset));
+	}
+	return JSON_INVALID;
+}
+
+uint8_t json_obj_bool(char* json, char* key, uint8_t fallback){
+	size_t offset = json_obj_offset(json, key);
+	if(offset){
+		if(!strncmp(json + offset, "true", 4)){
+			return 1;
+		}
+		if(!strncmp(json + offset, "false", 5)){
+			return 0;
+		}
+	}
+	return fallback;
+}
+
+int64_t json_obj_int(char* json, char* key, int64_t fallback){
+	char* next_token = NULL;
+	int64_t result;
+	size_t offset = json_obj_offset(json, key);
+	if(offset){
+		result = strtol(json + offset, &next_token, 10);
+		if(next_token != json + offset){
+			return result;
+		}
+	}
+	return fallback;
+}
+
+double json_obj_double(char* json, char* key, double fallback){
+	char* next_token = NULL;
+	int64_t result;
+	size_t offset = json_obj_offset(json, key);
+	if(offset){
+		result = strtod(json + offset, &next_token);
+		if(next_token != json + offset){
+			return result;
+		}
+	}
+	return fallback;
+}
+
+char* json_obj_str(char* json, char* key, size_t* length){
+	size_t offset = json_obj_offset(json, key), raw_length;
+	if(offset){
+		raw_length = json_validate_string(json + offset, strlen(json + offset));
+		if(length){
+			*length = raw_length - 2;
+		}
+		return json + offset + 1;
+	}
+	return NULL;
+}
+
+char* json_obj_strdup(char* json, char* key){
+	size_t offset = json_obj_offset(json, key), raw_length;
+	char* rv = NULL;
+	if(offset){
+		raw_length = json_validate_string(json + offset, strlen(json + offset));
+		rv = calloc(raw_length - 1, sizeof(char));
+		if(rv){
+			memcpy(rv, json + offset + 1, raw_length - 2);
+		}
+		return rv;
+	}
+	return NULL;
+}
diff --git a/backends/libmmbackend.h b/backends/libmmbackend.h
index 31c4b96..aa0ac0c 100644
--- a/backends/libmmbackend.h
+++ b/backends/libmmbackend.h
@@ -16,6 +16,10 @@
 #include <fcntl.h>
 #include "../portability.h"
 
+/*** BACKEND IMPLEMENTATION LIBRARY ***/
+
+/** Networking functions **/
+
 /* 
  * Parse spec as host specification in the form
  *	host port
@@ -49,3 +53,74 @@ int mmbackend_send(int fd, uint8_t* data, size_t length);
  * Wraps mmbackend_send for cstrings
  */
 int mmbackend_send_str(int fd, char* data);
+
+
+/** JSON parsing **/
+
+typedef enum /*_json_types*/ {
+	JSON_INVALID = 0,
+	JSON_STRING,
+	JSON_ARRAY,
+	JSON_OBJECT,
+	JSON_NUMBER,
+	JSON_BOOL,
+	JSON_NULL
+} json_type;
+
+/* 
+ * Try to identify the type of JSON data next in the buffer
+ * Will access at most the next `length` bytes
+ */
+json_type json_identify(char* json, size_t length);
+
+/* 
+ * Validate that a buffer contains a valid JSON document/data within `length` bytes
+ * Returns the length of a detected JSON document, 0 otherwise (ie. parse failures)
+ */
+size_t json_validate(char* json, size_t length);
+
+size_t json_validate_string(char* json, size_t length);
+
+size_t json_validate_array(char* json, size_t length);
+
+size_t json_validate_object(char* json, size_t length);
+
+size_t json_validate_value(char* json, size_t length);
+
+/* 
+ * Calculate offset for value of `key`
+ * Assumes a zero-terminated, validated JSON object as input
+ * Returns offset on success, 0 on failure
+ */
+size_t json_obj_offset(char* json, char* key);
+
+/*
+ * Check for for a key within a JSON object
+ * Assumes a zero-terminated, validated JSON object as input
+ * Returns type of value
+ */
+json_type json_obj(char* json, char* key);
+
+//json_type json_array(char* json, size_t index)
+
+/*
+ * Fetch boolean value for an object key
+ * Assumes a zero-terminated, validated JSON object as input
+ */
+uint8_t json_obj_bool(char* json, char* key, uint8_t fallback);
+
+/*
+ * Fetch integer/double value for an object key
+ * Assumes a zero-terminated validated JSON object as input
+ */
+int64_t json_obj_int(char* json, char* key, int64_t fallback);
+double json_obj_double(char* json, char* key, double fallback);
+
+/* 
+ * Fetch a string value for an object key
+ * Assumes a zero-terminated validated JSON object as input
+ * json_obj_strdup returns a newly-allocated buffer containing
+ * only the requested value
+ */
+char* json_obj_str(char* json, char* key, size_t* length);
+char* json_obj_strdup(char* json, char* key);
diff --git a/backends/maweb.c b/backends/maweb.c
new file mode 100644
index 0000000..be4c2ac
--- /dev/null
+++ b/backends/maweb.c
@@ -0,0 +1,695 @@
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#ifndef MAWEB_NO_LIBSSL
+#include <openssl/md5.h>
+#endif
+
+#include "libmmbackend.h"
+#include "maweb.h"
+
+#define BACKEND_NAME "maweb"
+#define WS_LEN(a) ((a) & 0x7F)
+#define WS_OP(a) ((a) & 0x0F)
+#define WS_FLAG_FIN 0x80
+#define WS_FLAG_MASK 0x80
+
+static uint64_t last_keepalive = 0;
+
+static char* cmdline_keys[] = {
+	"SET",
+	"PREV",
+	"NEXT",
+	"CLEAR",
+	"FIXTURE_CHANNEL",
+	"FIXTURE_GROUP_PRESET",
+	"EXEC_CUE",
+	"STORE_UPDATE",
+	"OOPS",
+	"ESC",
+	"0",
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"PUNKT",
+	"PLUS",
+	"MINUS",
+	"THRU",
+	"IF",
+	"AT",
+	"FULL",
+	"HIGH",
+	"ENTER",
+	"OFF",
+	"ON",
+	"ASSIGN",
+	"LABEL",
+	"COPY",
+	"TIME",
+	"PAGE",
+	"MACRO",
+	"DELETE",
+	"GOTO",
+	"GO_PLUS",
+	"GO_MINUS",
+	"PAUSE",
+	"SELECT",
+	"FIXTURE",
+	"SEQU",
+	"CUE",
+	"PRESET",
+	"EDIT",
+	"UPDATE",
+	"EXEC",
+	"STORE",
+	"GROUP",
+	"PROG_ONLY",
+	"SPECIAL_DIALOGUE",
+	"SOLO",
+	"ODD",
+	"EVEN",
+	"WINGS",
+	"RESET",
+	"MA",
+	"layerMode",
+	"featureSort",
+	"fixtureSort",
+	"channelSort",
+	"hideName"
+};
+
+int init(){
+	backend maweb = {
+		.name = BACKEND_NAME,
+		.conf = maweb_configure,
+		.create = maweb_instance,
+		.conf_instance = maweb_configure_instance,
+		.channel = maweb_channel,
+		.handle = maweb_set,
+		.process = maweb_handle,
+		.start = maweb_start,
+		.shutdown = maweb_shutdown
+	};
+
+	if(sizeof(maweb_channel_ident) != sizeof(uint64_t)){
+		fprintf(stderr, "maweb channel identification union out of bounds\n");
+		return 1;
+	}
+
+	//register backend
+	if(mm_backend_register(maweb)){
+		fprintf(stderr, "Failed to register maweb backend\n");
+		return 1;
+	}
+	return 0;
+}
+
+static int maweb_configure(char* option, char* value){
+	fprintf(stderr, "The maweb backend does not take any global configuration\n");
+	return 1;
+}
+
+static int maweb_configure_instance(instance* inst, char* option, char* value){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	char* host = NULL, *port = NULL;
+	#ifndef MAWEB_NO_LIBSSL
+	uint8_t password_hash[MD5_DIGEST_LENGTH];
+	#endif
+
+	if(!strcmp(option, "host")){
+		mmbackend_parse_hostspec(value, &host, &port);
+		if(!host){
+			fprintf(stderr, "Invalid host specified for maweb instance %s\n", inst->name);
+			return 1;
+		}
+		free(data->host);
+		data->host = strdup(host);
+		free(data->port);
+		data->port = NULL;
+		if(port){
+			data->port = strdup(port);
+		}
+		return 0;
+	}
+	else if(!strcmp(option, "user")){
+		free(data->user);
+		data->user = strdup(value);
+		return 0;
+	}
+	else if(!strcmp(option, "password")){
+		#ifndef MAWEB_NO_LIBSSL
+		size_t n;
+		MD5((uint8_t*) value, strlen(value), (uint8_t*) password_hash);
+		data->pass = realloc(data->pass, (2 * MD5_DIGEST_LENGTH + 1) * sizeof(char));
+		for(n = 0; n < MD5_DIGEST_LENGTH; n++){
+			snprintf(data->pass + 2 * n, 3, "%02x", password_hash[n]);
+		}
+		return 0;
+		#else
+		fprintf(stderr, "This build of the maweb backend only supports the default password\n");
+		return 1;
+		#endif
+	}
+
+	fprintf(stderr, "Unknown configuration parameter %s for manet instance %s\n", option, inst->name);
+	return 1;
+}
+
+static instance* maweb_instance(){
+	instance* inst = mm_instance();
+	if(!inst){
+		return NULL;
+	}
+
+	maweb_instance_data* data = calloc(1, sizeof(maweb_instance_data));
+	if(!data){
+		fprintf(stderr, "Failed to allocate memory\n");
+		return NULL;
+	}
+
+	data->fd = -1;
+	data->buffer = calloc(MAWEB_RECV_CHUNK, sizeof(uint8_t));
+	if(!data->buffer){
+		fprintf(stderr, "Failed to allocate memory\n");
+		free(data);
+		return NULL;
+	}
+	data->allocated = MAWEB_RECV_CHUNK;
+
+	inst->impl = data;
+	return inst;
+}
+
+static channel* maweb_channel(instance* inst, char* spec){
+	maweb_channel_ident ident = {
+		.label = 0
+	};
+	char* next_token = NULL;
+	size_t n;
+
+	if(!strncmp(spec, "page", 4)){
+		ident.fields.page = strtoul(spec + 4, &next_token, 10);
+		if(*next_token != '.'){
+			fprintf(stderr, "Failed to parse maweb channel spec %s: Missing separator\n", spec);
+			return NULL;
+		}
+
+		next_token++;
+		if(!strncmp(next_token, "fader", 5)){
+			ident.fields.type = exec_fader;
+			next_token += 5;
+		}
+		else if(!strncmp(next_token, "upper", 5)){
+			ident.fields.type = exec_upper;
+			next_token += 5;
+		}
+		else if(!strncmp(next_token, "lower", 5)){
+			ident.fields.type = exec_lower;
+			next_token += 5;
+		}
+		else if(!strncmp(next_token, "flash", 5)){
+			ident.fields.type = exec_flash;
+			next_token += 5;
+		}
+		else if(!strncmp(next_token, "button", 6)){
+			ident.fields.type = exec_fader;
+			next_token += 6;
+		}
+		ident.fields.index = strtoul(next_token, NULL, 10);
+	}
+	else{
+		for(n = 0; n < sizeof(cmdline_keys) / sizeof(char*); n++){
+			if(!strcmp(spec, cmdline_keys[n])){
+				ident.fields.type = cmdline_button;
+				ident.fields.index = n + 1;
+				ident.fields.page = 1;
+				break;
+			}
+		}
+	}
+
+	if(ident.fields.type && ident.fields.index && ident.fields.page
+			&& ident.fields.index <= 90){
+		//actually, those are zero-indexed...
+		ident.fields.index--;
+		ident.fields.page--;
+		return mm_channel(inst, ident.label, 1);
+	}
+	fprintf(stderr, "Failed to parse maweb channel spec %s\n", spec);
+	return NULL;
+}
+
+static int maweb_send_frame(instance* inst, maweb_operation op, uint8_t* payload, size_t len){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	uint8_t frame_header[MAWEB_FRAME_HEADER_LENGTH] = "";
+	size_t header_bytes = 2;
+	uint16_t* payload_len16 = (uint16_t*) (frame_header + 2);
+	uint64_t* payload_len64 = (uint64_t*) (frame_header + 2);
+
+	frame_header[0] = WS_FLAG_FIN | op;
+	if(len <= 125){
+		frame_header[1] = WS_FLAG_MASK | len;
+	}
+	else if(len <= 0xFFFF){
+		frame_header[1] = WS_FLAG_MASK | 126;
+		*payload_len16 = htobe16(len);
+		header_bytes += 2;
+	}
+	else{
+		frame_header[1] = WS_FLAG_MASK | 127;
+		*payload_len64 = htobe64(len);
+		header_bytes += 8;
+	}
+	//send a zero masking key because masking is stupid
+	header_bytes += 4;
+
+	if(mmbackend_send(data->fd, frame_header, header_bytes)
+			|| mmbackend_send(data->fd, payload, len)){
+		return 1;
+	}
+
+	return 0;
+}
+
+static int maweb_handle_message(instance* inst, char* payload, size_t payload_length){
+	char xmit_buffer[MAWEB_XMIT_CHUNK];
+	char* field;
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+
+	fprintf(stderr, "maweb message (%lu): %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);
+	}
+
+	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}",
+				data->user, data->pass, data->session);
+		maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+	}
+
+	if(json_obj(payload, "status") && json_obj(payload, "appType")){
+		fprintf(stderr, "maweb connection established\n");
+		maweb_send_frame(inst, ws_text, (uint8_t*) "{\"session\":0}", 13);
+	}
+
+	if(json_obj(payload, "responseType") == JSON_STRING){
+		field = json_obj_str(payload, "responseType", NULL);
+		if(!strncmp(field, "login", 5)){
+			if(json_obj_bool(payload, "result", 0)){
+				fprintf(stderr, "maweb login successful\n");
+				data->login = 1;
+			}
+			else{
+				fprintf(stderr, "maweb login failed\n");
+				data->login = 0;
+			}
+		}
+		else if(!strncmp(field, "getdata", 7)){
+			//FIXME stupid keepalive logic
+			snprintf(xmit_buffer, sizeof(xmit_buffer),
+					"{\"requestType\":\"getdata\","
+					"\"data\":\"set,clear,solo,high\","
+					"\"realtime\":true,"
+					"\"maxRequests\":10,"
+					",\"session\":%ld}",
+					data->session);
+			maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+		}
+	}
+
+	return 0;
+}
+
+static int maweb_connect(instance* inst){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	if(!data->host){
+		return 1;
+	}
+
+	//unregister old fd from core
+	if(data->fd >= 0){
+		mm_manage_fd(data->fd, BACKEND_NAME, 0, NULL);
+	}
+
+	data->fd = mmbackend_socket(data->host, data->port ? data->port : MAWEB_DEFAULT_PORT, SOCK_STREAM, 0, 0);
+	if(data->fd < 0){
+		return 1;
+	}
+
+	data->state = ws_new;
+	if(mmbackend_send_str(data->fd, "GET /?ma=1 HTTP/1.1\r\n")
+			|| mmbackend_send_str(data->fd, "Connection: Upgrade\r\n")
+			|| mmbackend_send_str(data->fd, "Upgrade: websocket\r\n")
+			|| mmbackend_send_str(data->fd, "Sec-WebSocket-Version: 13\r\n")
+			//the websocket key probably should not be hardcoded, but this is not security criticial
+			//and the whole websocket 'accept key' dance is plenty stupid as it is
+			|| mmbackend_send_str(data->fd, "Sec-WebSocket-Key: rbEQrXMEvCm4ZUjkj6juBQ==\r\n")
+			|| mmbackend_send_str(data->fd, "\r\n")){
+		fprintf(stderr, "maweb backend failed to communicate with peer\n");
+		return 1;
+	}
+
+	//register new fd
+	if(mm_manage_fd(data->fd, BACKEND_NAME, 1, (void*) inst)){
+		fprintf(stderr, "maweb backend failed to register fd\n");
+		return 1;
+	}
+	return 0;
+}
+
+static ssize_t maweb_handle_lines(instance* inst, ssize_t bytes_read){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	size_t n, begin = 0;
+
+	for(n = 0; n < bytes_read - 2; n++){
+		if(!strncmp((char*) data->buffer + data->offset + n, "\r\n", 2)){
+			if(data->state == ws_new){
+				if(!strncmp((char*) data->buffer, "HTTP/1.1 101", 12)){
+					data->state = ws_http;
+				}
+				else{
+					fprintf(stderr, "maweb received invalid HTTP response for instance %s\n", inst->name);
+					return -1;
+				}
+			}
+			else{
+				//ignore all http stuff until the end of headers since we don't actually care...
+				if(n == begin){
+					data->state = ws_open;
+				}
+			}
+			begin = n + 2;
+		}
+	}
+
+	return begin;
+}
+
+static ssize_t maweb_handle_ws(instance* inst, ssize_t bytes_read){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	size_t header_length = 2;
+	uint64_t payload_length = 0;
+	uint16_t* payload_len16 = (uint16_t*) (data->buffer + 2);
+	uint64_t* payload_len64 = (uint64_t*) (data->buffer + 2);
+	uint8_t* payload = data->buffer + 2;
+	uint8_t terminator_temp = 0;
+
+	if(data->offset + bytes_read < 2){
+		return 0;
+	}
+
+	//using varint as payload length is stupid, but some people seem to think otherwise...
+	payload_length = WS_LEN(data->buffer[1]);
+	switch(payload_length){
+		case 126:
+			if(data->offset + bytes_read < 4){
+				return 0;
+			}
+			payload_length = htobe16(*payload_len16);
+			payload = data->buffer + 4;
+			header_length = 4;
+			break;
+		case 127:
+			if(data->offset + bytes_read < 10){
+				return 0;
+			}
+			payload_length = htobe64(*payload_len64);
+			payload = data->buffer + 10;
+			header_length = 10;
+			break;
+		default:
+			break;
+	}
+
+	if(data->offset + bytes_read < header_length + payload_length){
+		return 0;
+	}
+
+	switch(WS_OP(data->buffer[0])){
+		case ws_text:
+			//terminate message
+			terminator_temp = payload[payload_length];
+			payload[payload_length] = 0;
+			if(maweb_handle_message(inst, (char*) payload, payload_length)){
+				return data->offset + bytes_read;
+			}
+			payload[payload_length] = terminator_temp;
+			break;
+		case ws_ping:
+			//answer server ping with a pong
+			if(maweb_send_frame(inst, ws_pong, payload, payload_length)){
+				fprintf(stderr, "maweb failed to send pong\n");
+			}
+			return header_length + payload_length;
+		default:
+			fprintf(stderr, "maweb encountered unhandled frame type %02X\n", WS_OP(data->buffer[0]));
+			//this is somewhat dicey, it might be better to handle only header + payload length for known but unhandled types
+			return data->offset + bytes_read;
+	}
+
+	return header_length + payload_length;
+}
+
+static int maweb_handle_fd(instance* inst){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	ssize_t bytes_read, bytes_left = data->allocated - data->offset, bytes_handled;
+
+	if(bytes_left < 3){
+		data->buffer = realloc(data->buffer, (data->allocated + MAWEB_RECV_CHUNK) * sizeof(uint8_t));
+		if(!data->buffer){
+			fprintf(stderr, "Failed to allocate memory\n");
+			return 1;
+		}
+		data->allocated += MAWEB_RECV_CHUNK;
+		bytes_left += MAWEB_RECV_CHUNK;
+	}
+
+	bytes_read = recv(data->fd, data->buffer + data->offset, bytes_left - 1, 0);
+	if(bytes_read < 0){
+		fprintf(stderr, "maweb backend failed to receive: %s\n", strerror(errno));
+		//TODO close, reopen
+		return 1;
+	}
+	else if(bytes_read == 0){
+		//client closed connection
+		//TODO try to reopen
+		return 0;
+	}
+
+	do{
+		switch(data->state){
+			case ws_new:
+			case ws_http:
+				bytes_handled = maweb_handle_lines(inst, bytes_read);
+				break;
+			case ws_open:
+				bytes_handled = maweb_handle_ws(inst, bytes_read);
+				break;
+			case ws_closed:
+				bytes_handled = data->offset + bytes_read;
+				break;
+		}
+
+		if(bytes_handled < 0){
+			bytes_handled = data->offset + bytes_read;
+			//TODO close, reopen
+			fprintf(stderr, "maweb failed to handle incoming data\n");
+			return 1;
+		}
+		else if(bytes_handled == 0){
+			 break;
+		}
+
+		memmove(data->buffer, data->buffer + bytes_handled, (data->offset + bytes_read) - bytes_handled);
+
+		//FIXME this might be somewhat borked
+		bytes_read -= data->offset;
+		bytes_handled -= data->offset;
+		bytes_read -= bytes_handled;
+		data->offset = 0;
+	} while(bytes_read > 0);
+
+	data->offset += bytes_read;
+	return 0;
+}
+
+static int maweb_set(instance* inst, size_t num, channel** c, channel_value* v){
+	maweb_instance_data* data = (maweb_instance_data*) inst->impl;
+	char xmit_buffer[MAWEB_XMIT_CHUNK];
+	maweb_channel_ident ident;
+	size_t n;
+
+	if(num && !data->login){
+		fprintf(stderr, "maweb instance %s can not send output, not logged in\n", inst->name);
+	}
+
+	for(n = 0; n < num; n++){
+		ident.label = c[n]->ident;
+		switch(ident.fields.type){
+			case exec_fader:
+				snprintf(xmit_buffer, sizeof(xmit_buffer),
+						"{\"requestType\":\"playbacks_userInput\","
+						"\"execIndex\":%d,"
+						"\"pageIndex\":%d,"
+						"\"faderValue\":%f,"
+						"\"type\":1,"
+						"\"session\":%ld"
+						"}", ident.fields.index, ident.fields.page, v[n].normalised, data->session);
+				fprintf(stderr, "maweb out %s\n", xmit_buffer);
+				maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+				break;
+			case exec_upper:
+			case exec_lower:
+			case exec_flash:
+				snprintf(xmit_buffer, sizeof(xmit_buffer),
+						"{\"requestType\":\"playbacks_userInput\","
+						//"\"cmdline\":\"\","
+						"\"execIndex\":%d,"
+						"\"pageIndex\":%d,"
+						"\"buttonId\":%d,"
+						"\"pressed\":%s,"
+						"\"released\":%s,"
+						"\"type\":0,"
+						"\"session\":%ld"
+						"}", ident.fields.index, ident.fields.page,
+						(exec_flash - ident.fields.type),
+						(v[n].normalised > 0.9) ? "true" : "false",
+						(v[n].normalised > 0.9) ? "false" : "true",
+						data->session);
+				fprintf(stderr, "maweb out %s\n", xmit_buffer);
+				maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+				break;
+			case cmdline_button:
+				snprintf(xmit_buffer, sizeof(xmit_buffer),
+						"{\"keyname\":\"%s\","
+						//"\"autoSubmit\":false,"
+						"\"value\":%d"
+						"}", cmdline_keys[ident.fields.index],
+						(v[n].normalised > 0.9) ? 1 : 0);
+				fprintf(stderr, "maweb out %s\n", xmit_buffer);
+				maweb_send_frame(inst, ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+				break;
+			default:
+				fprintf(stderr, "maweb control not yet implemented\n");
+				break;
+		}
+	}
+	return 0;
+}
+
+static int maweb_keepalive(){
+	size_t n, u;
+	instance** inst = NULL;
+	maweb_instance_data* data = NULL;
+	char xmit_buffer[MAWEB_XMIT_CHUNK];
+
+	//fetch all defined instances
+	if(mm_backend_instances(BACKEND_NAME, &n, &inst)){
+		fprintf(stderr, "Failed to fetch instance list\n");
+		return 1;
+	}
+
+	//send keep-alive messages for logged-in instances
+	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);
+			maweb_send_frame(inst[u], ws_text, (uint8_t*) xmit_buffer, strlen(xmit_buffer));
+		}
+	}
+
+	free(inst);
+	return 0;
+}
+
+static int maweb_handle(size_t num, managed_fd* fds){
+	size_t n = 0;
+	int rv = 0;
+
+	for(n = 0; n < num; n++){
+		rv |= maweb_handle_fd((instance*) fds[n].impl);
+	}
+
+	if(last_keepalive && mm_timestamp() - last_keepalive >= MAWEB_CONNECTION_KEEPALIVE){
+		rv |= maweb_keepalive();
+		last_keepalive = mm_timestamp();
+	}
+
+	return rv;
+}
+
+static int maweb_start(){
+	size_t n, u;
+	instance** inst = NULL;
+
+	//fetch all defined instances
+	if(mm_backend_instances(BACKEND_NAME, &n, &inst)){
+		fprintf(stderr, "Failed to fetch instance list\n");
+		return 1;
+	}
+
+	for(u = 0; u < n; u++){
+		if(maweb_connect(inst[u])){
+			fprintf(stderr, "Failed to open connection to MA Web Remote for instance %s\n", inst[u]->name);
+			return 1;
+		}
+	}
+
+	free(inst);
+	if(!n){
+		return 0;
+	}
+
+	fprintf(stderr, "maweb backend registering %lu descriptors to core\n", n);
+
+	//initialize keepalive timeout
+	last_keepalive = mm_timestamp();
+	return 0;
+}
+
+static int maweb_shutdown(){
+	size_t n, u;
+	instance** inst = NULL;
+	maweb_instance_data* data = NULL;
+
+	//fetch all instances
+	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 = (maweb_instance_data*) inst[u]->impl;
+		free(data->host);
+		data->host = NULL;
+		free(data->port);
+		data->port = NULL;
+		free(data->user);
+		data->user = NULL;
+		free(data->pass);
+		data->pass = NULL;
+
+		close(data->fd);
+		data->fd = -1;
+
+		free(data->buffer);
+		data->buffer = NULL;
+
+		data->offset = data->allocated = 0;
+		data->state = ws_new;
+	}
+
+	free(inst);
+
+	fprintf(stderr, "maweb backend shut down\n");
+	return 0;
+}
diff --git a/backends/maweb.h b/backends/maweb.h
new file mode 100644
index 0000000..6e6e652
--- /dev/null
+++ b/backends/maweb.h
@@ -0,0 +1,69 @@
+#include "midimonster.h"
+
+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 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();
+static int maweb_shutdown();
+
+//Default login password: MD5("midimonster")
+#define MAWEB_DEFAULT_PASSWORD "2807623134739142b119aff358f8a219"
+#define MAWEB_DEFAULT_PORT "80"
+#define MAWEB_RECV_CHUNK 1024
+#define MAWEB_XMIT_CHUNK 2048
+#define MAWEB_FRAME_HEADER_LENGTH 16
+#define MAWEB_CONNECTION_KEEPALIVE 10000
+
+typedef enum /*_maweb_channel_type*/ {
+	type_unset = 0,
+	exec_fader = 1,
+	exec_button = 2,
+	exec_upper = 3,
+	exec_lower = 4,
+	exec_flash = 5,
+	cmdline_button
+} maweb_channel_type;
+
+typedef enum /*_ws_conn_state*/ {
+	ws_new,
+	ws_http,
+	ws_open,
+	ws_closed
+} maweb_state;
+
+typedef enum /*_ws_frame_op*/ {
+	ws_text = 1,
+	ws_binary = 2,
+	ws_ping = 9,
+	ws_pong = 10
+} maweb_operation;
+
+typedef union {
+	struct {
+		uint8_t padding[3];
+		uint8_t type;
+		uint16_t page;
+		uint16_t index;
+	} fields;
+	uint64_t label;
+} maweb_channel_ident;
+
+typedef struct /*_maweb_instance_data*/ {
+	char* host;
+	char* port;
+	char* user;
+	char* pass;
+	
+	uint8_t login;
+	int64_t session;
+
+	int fd;
+	maweb_state state;
+	size_t offset;
+	size_t allocated;
+	uint8_t* buffer;
+} maweb_instance_data;
diff --git a/backends/maweb.md b/backends/maweb.md
new file mode 100644
index 0000000..eb1ed44
--- /dev/null
+++ b/backends/maweb.md
@@ -0,0 +1,142 @@
+### The `maweb` backend
+
+This backend connects directly with the integrated *MA Web Remote* of MA Lighting consoles and OnPC
+instances (GrandMA2 / GrandMA2 OnPC / GrandMA Dot2 / GrandMA Dot2 OnPC).
+It grants read-write access to the console's playback faders and buttons as well as write access to
+the command line buttons.
+
+To allow this backend to connect to the console, enter the console configuration (`Setup` key),
+select `Console`/`Global Settings` and set the `Remotes` option to `Login enabled`.
+Create an additional user that is able to log into the Web Remote using `Setup`/`Console`/`User & Profiles Setup`.
+
+#### Global configuration
+
+The `maweb` backend does not take any global configuration.
+
+#### Instance configuration
+
+| Option        | Example value         | Default value         | Description							|
+|---------------|-----------------------|-----------------------|---------------------------------------------------------------|
+| `host`	| `10.23.42.21 80`     	| none                  | Host address (and optional port) of the MA Web Remote 	|
+| `user`	| `midimonster`		| none			| User for the remote session					|
+| `password`	| `midimonster`		| `midimonster`		| Password for the remote session				|
+
+#### Channel specification
+
+Currently, three types of channels can be assigned
+
+##### Executors
+
+Executors are arranged in pages, with each page having 90 fader executors and 90 button executors.
+Note that when creating a new show, only the first page is created and active.
+
+A fader executor consists of a fader, two buttons (`upper`, `lower`) above it and one `flash` button below it.
+
+These controls can be adressed like
+
+```
+mw1.page1.fader5 > mw1.page1.upper5
+mw1.page3.lower3 > mw1.page2.flash2
+```
+
+A button executor can likewise be mapped using the syntax
+
+```
+mw1.page2.button3 > mw1.page3.fader1
+```
+
+##### Command line buttons
+
+Command line buttons will be pressed when the incoming event value is greater than `0.9` and released when it is less than that.
+They can be mapped using the syntax
+
+```
+mw1.<button-name>
+```
+
+The following button names are recognized by the backend:
+
+* `SET`
+* `PREV`
+* `NEXT`
+* `CLEAR`
+* `FIXTURE_CHANNEL`
+* `FIXTURE_GROUP_PRESET`
+* `EXEC_CUE`
+* `STORE_UPDATE`
+* `OOPS`
+* `ESC`
+* `0`
+* `1`
+* `2`
+* `3`
+* `4`
+* `5`
+* `6`
+* `7`
+* `8`
+* `9`
+* `PUNKT`
+* `PLUS`
+* `MINUS`
+* `THRU`
+* `IF`
+* `AT`
+* `FULL`
+* `HIGH`
+* `ENTER`
+* `OFF`
+* `ON`
+* `ASSIGN`
+* `LABEL`
+* `COPY`
+* `TIME`
+* `PAGE`
+* `MACRO`
+* `DELETE`
+* `GOTO`
+* `GO_PLUS`
+* `GO_MINUS`
+* `PAUSE`
+* `SELECT`
+* `FIXTURE`
+* `SEQU`
+* `CUE`
+* `PRESET`
+* `EDIT`
+* `UPDATE`
+* `EXEC`
+* `STORE`
+* `GROUP`
+* `PROG_ONLY`
+* `SPECIAL_DIALOGUE`
+* `SOLO`
+* `ODD`
+* `EVEN`
+* `WINGS`
+* `RESET`
+* `MA`
+* `layerMode`
+* `featureSort`
+* `fixtureSort`
+* `channelSort`
+* `hideName`
+
+Note that each Web Remote connection has it's own command line, as such commands entered using this backend will not affect
+the command line on the main console. To do that, you will need to use another backend to feed input to the MA, such as
+the ArtNet or MIDI backends.
+
+#### Known bugs / problems
+
+To properly encode the user password, this backend depends on a library providing cryptographic functions (`libssl` / `openssl`).
+Since this may be a problem on some platforms, the backend can be built with this requirement disabled, which also disables the possibility
+to set arbitrary passwords. The backend will always try to log in with the default password `midimonster` in this case. The user name is still
+configurable.
+
+This backend is currently in active development. It therefore has some limitations:
+
+* It outputs a lot of debug information
+* It currently is write-only, channel events are only sent to the MA, not consumed by it
+* Fader executors (and their buttons) seem to work, I haven't tested button executors yet.
+* Command line events are sent, but I'm not sure they're being handled yet
+* I have so far only tested it with GradMA2 OnPC
diff --git a/midimonster.c b/midimonster.c
index 1e47698..25cf4a0 100644
--- a/midimonster.c
+++ b/midimonster.c
@@ -298,6 +298,9 @@ int main(int argc, char** argv){
 		plugins_close();
 		return usage(argv[0]);
 	}
+	
+	//load an initial timestamp
+	update_timestamp();
 
 	//start backends
 	if(backends_start()){
diff --git a/monster.cfg b/monster.cfg
index 2413f6d..d272cee 100644
--- a/monster.cfg
+++ b/monster.cfg
@@ -7,6 +7,33 @@ bind = 0.0.0.0
 universe = 0
 dest = 255.255.255.255
 
+[backend midi]
+detect = on
+
+[backend evdev]
+;detect = on
+
+[midi bcf]
+read = BCF
+write = BCF
+
+[evdev mouse]
+input = TPPS
+relaxis.REL_X = 255
+relaxis.REL_Y = -255
+
+[maweb ma]
+;host = 10.23.23.248
+host = 127.0.0.1 4040
+user = web
+password = web
+
 [map]
+bcf.channel{0..7}.pitch > bcf.channel{0..7}.pitch
+bcf.channel{0..7}.pitch > art.{1..8}
 
-art.1+2 > loop.b
+bcf.channel{0..7}.pitch > ma.page1.fader{1..8}
+bcf.channel0.note{16..23} > ma.page1.upper{1..8}
+bcf.channel0.note{24..31} > ma.page1.lower{1..8}
+mouse.EV_REL.REL_Y > ma.page1.fader1
+mouse.EV_KEY.BTN_LEFT > ma.ASSIGN
-- 
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 'TODO')

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