From adc132b5fc039a185be947de3309bd11f4dee823 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 1 Jan 2021 19:22:01 +0100
Subject: Implement EPN transmission for the midi backend

---
 backends/midi.c  | 90 +++++++++++++++++++++++++++++++++++++++++++-------------
 backends/midi.h  |  8 +++--
 backends/midi.md | 10 +++++++
 3 files changed, 85 insertions(+), 23 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index 1f0f2d5..8a8887a 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -13,7 +13,9 @@ enum /*_midi_channel_type*/ {
 	cc,
 	pressure,
 	aftertouch,
-	pitchbend
+	pitchbend,
+	rpn,
+	nrpn
 };
 
 static struct {
@@ -99,6 +101,13 @@ static int midi_configure_instance(instance* inst, char* option, char* value){
 		data->write = strdup(value);
 		return 0;
 	}
+	else if(!strcmp(option, "epn-tx")){
+		data->epn_tx_short = 0;
+		if(!strcmp(value, "short")){
+			data->epn_tx_short = 1;
+		}
+		return 0;
+	}
 
 	LOGPF("Unknown instance option %s", option);
 	return 1;
@@ -147,6 +156,14 @@ static channel* midi_channel(instance* inst, char* spec, uint8_t flags){
 		ident.fields.type = pressure;
 		channel += 8;
 	}
+	else if(!strncmp(channel, "rpn", 3)){
+		ident.fields.type = rpn;
+		channel += 3;
+	}
+	else if(!strncmp(channel, "nrpn", 4)){
+		ident.fields.type = nrpn;
+		channel += 4;
+	}
 	else if(!strncmp(channel, "pitch", 5)){
 		ident.fields.type = pitchbend;
 	}
@@ -167,9 +184,37 @@ static channel* midi_channel(instance* inst, char* spec, uint8_t flags){
 	return NULL;
 }
 
+static void midi_tx(int port, uint8_t type, uint8_t channel, uint8_t control, uint16_t value){
+	snd_seq_event_t ev;
+
+	snd_seq_ev_clear(&ev);
+	snd_seq_ev_set_source(&ev, port);
+	snd_seq_ev_set_subs(&ev);
+	snd_seq_ev_set_direct(&ev);
+
+	switch(type){
+		case note:
+			snd_seq_ev_set_noteon(&ev, channel, control, value);
+			break;
+		case cc:
+			snd_seq_ev_set_controller(&ev, channel, control, value);
+			break;
+		case pressure:
+			snd_seq_ev_set_keypress(&ev, channel, control, value);
+			break;
+		case pitchbend:
+			snd_seq_ev_set_pitchbend(&ev, channel, value);
+			break;
+		case aftertouch:
+			snd_seq_ev_set_chanpress(&ev, channel, value);
+			break;
+	}
+
+	snd_seq_event_output(sequencer, &ev);
+}
+
 static int midi_set(instance* inst, size_t num, channel** c, channel_value* v){
 	size_t u;
-	snd_seq_event_t ev;
 	midi_instance_data* data = (midi_instance_data*) inst->impl;
 	midi_channel_ident ident = {
 		.label = 0
@@ -178,30 +223,28 @@ static int midi_set(instance* inst, size_t num, channel** c, channel_value* v){
 	for(u = 0; u < num; u++){
 		ident.label = c[u]->ident;
 
-		snd_seq_ev_clear(&ev);
-		snd_seq_ev_set_source(&ev, data->port);
-		snd_seq_ev_set_subs(&ev);
-		snd_seq_ev_set_direct(&ev);
-
 		switch(ident.fields.type){
-			case note:
-				snd_seq_ev_set_noteon(&ev, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
-				break;
-			case cc:
-				snd_seq_ev_set_controller(&ev, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
-				break;
-			case pressure:
-				snd_seq_ev_set_keypress(&ev, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
+			case rpn:
+			case nrpn:
+				//transmit parameter number
+				midi_tx(data->port, cc, ident.fields.channel, (ident.fields.type == rpn) ? 101 : 99, (ident.fields.control & 0x3F80) >> 7);
+				midi_tx(data->port, cc, ident.fields.channel, (ident.fields.type == rpn) ? 100 : 98, ident.fields.control & 0x7F);
+				//transmit parameter value
+				midi_tx(data->port, cc, ident.fields.channel, 6, (((uint16_t) (v[u].normalised * 16383.0)) & 0x3F80) >> 7);
+				midi_tx(data->port, cc, ident.fields.channel, 38, ((uint16_t) (v[u].normalised * 16383.0)) & 0x7F);
+
+				if(!data->epn_tx_short){
+					//clear active parameter
+					midi_tx(data->port, cc, ident.fields.channel, 101, 127);
+					midi_tx(data->port, cc, ident.fields.channel, 100, 127);
+				}
 				break;
 			case pitchbend:
-				snd_seq_ev_set_pitchbend(&ev, ident.fields.channel, (v[u].normalised * 16383.0) - 8192);
-				break;
-			case aftertouch:
-				snd_seq_ev_set_chanpress(&ev, ident.fields.channel, v[u].normalised * 127.0);
+				midi_tx(data->port, ident.fields.type, ident.fields.channel, ident.fields.control, (v[u].normalised * 16383.0) - 8192);
 				break;
+			default:
+				midi_tx(data->port, ident.fields.type, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
 		}
-
-		snd_seq_event_output(sequencer, &ev);
 	}
 
 	snd_seq_drain_output(sequencer);
@@ -216,6 +259,10 @@ static char* midi_type_name(uint8_t type){
 			return "note";
 		case cc:
 			return "cc";
+		case rpn:
+			return "rpn";
+		case nrpn:
+			return "nrpn";
 		case pressure:
 			return "pressure";
 		case aftertouch:
@@ -248,6 +295,7 @@ static int midi_handle(size_t num, managed_fd* fds){
 		ident.fields.control = ev->data.note.note;
 		val.normalised = (double) ev->data.note.velocity / 127.0;
 
+		//TODO (n)rpn RX
 		switch(ev->type){
 			case SND_SEQ_EVENT_NOTEON:
 			case SND_SEQ_EVENT_NOTEOFF:
diff --git a/backends/midi.h b/backends/midi.h
index dcee010..4e2ac09 100644
--- a/backends/midi.h
+++ b/backends/midi.h
@@ -14,14 +14,18 @@ typedef struct /*_midi_instance_data*/ {
 	int port;
 	char* read;
 	char* write;
+	uint8_t epn_tx_short;
+
+	uint16_t epn_control;
+	uint16_t epn_value;
 } midi_instance_data;
 
 typedef union {
 	struct {
-		uint8_t pad[5];
+		uint8_t pad[4];
 		uint8_t type;
 		uint8_t channel;
-		uint8_t control;
+		uint16_t control;
 	} fields;
 	uint64_t label;
 } midi_channel_ident;
diff --git a/backends/midi.md b/backends/midi.md
index d3d6e33..3ac011e 100644
--- a/backends/midi.md
+++ b/backends/midi.md
@@ -15,6 +15,7 @@ The MIDI backend provides read-write access to the MIDI protocol via virtual por
 |---------------|-----------------------|-----------------------|-----------------------|
 | `read`	| `20:0`		| none			| MIDI device to connect for input |
 | `write`	| `DeviceName`		| none			| MIDI device to connect for output |
+| `epn-tx`	| `short`		| `full`		| Configures whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter |
 
 MIDI device names may either be `client:port` portnames or prefixes of MIDI device names.
 Run `aconnect -i` to list input ports and `aconnect -o` to list output ports.
@@ -30,6 +31,8 @@ The MIDI backend supports mapping different MIDI events to MIDIMonster channels.
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `rpn` - Registered parameter numbers (14bit extension)
+* `nrpn` - Non-registered parameter numbers (14bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
@@ -40,15 +43,22 @@ MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (n
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
 'channel aftertouch') and a pitch control which may all be mapped to individual MIDIMonster channels.
 
+Every channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
+the CC controls 101/100/99/98/38/6. Both control types have 14-bit IDs and 14-bit values.
+
 Example mappings:
 ```
 midi1.ch0.note9 > midi2.channel1.cc4
 midi1.channel15.pressure1 > midi1.channel0.note0
 midi1.ch1.aftertouch > midi2.ch2.cc0
 midi1.ch0.pitch > midi2.ch1.pitch
+midi1.ch0.nrpn900 > midi2.ch0.rpn1
 ```
 #### Known bugs / problems
 
+Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
+received as such. Support for this functionality is planned.
+
 To access MIDI data, the user running MIDIMonster needs read & write access to the ALSA sequencer.
 This can usually be done by adding this user to the `audio` system group.
 
-- 
cgit v1.2.3


From 26b91b849899976b455bc5d780688de6962569e1 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 2 Jan 2021 17:15:57 +0100
Subject: Implement EPN transmission for the winmidi backend

---
 backends/midi.c     |  6 ++--
 backends/midi.md    |  6 ++--
 backends/winmidi.c  | 85 +++++++++++++++++++++++++++++++++++++++++------------
 backends/winmidi.h  |  9 ++++--
 backends/winmidi.md | 10 +++++++
 5 files changed, 88 insertions(+), 28 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index 8a8887a..d581a01 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -109,7 +109,7 @@ static int midi_configure_instance(instance* inst, char* option, char* value){
 		return 0;
 	}
 
-	LOGPF("Unknown instance option %s", option);
+	LOGPF("Unknown instance configuration option %s on instance %s", option, inst->name);
 	return 1;
 }
 
@@ -227,10 +227,10 @@ static int midi_set(instance* inst, size_t num, channel** c, channel_value* v){
 			case rpn:
 			case nrpn:
 				//transmit parameter number
-				midi_tx(data->port, cc, ident.fields.channel, (ident.fields.type == rpn) ? 101 : 99, (ident.fields.control & 0x3F80) >> 7);
+				midi_tx(data->port, cc, ident.fields.channel, (ident.fields.type == rpn) ? 101 : 99, (ident.fields.control >> 7) & 0x7F);
 				midi_tx(data->port, cc, ident.fields.channel, (ident.fields.type == rpn) ? 100 : 98, ident.fields.control & 0x7F);
 				//transmit parameter value
-				midi_tx(data->port, cc, ident.fields.channel, 6, (((uint16_t) (v[u].normalised * 16383.0)) & 0x3F80) >> 7);
+				midi_tx(data->port, cc, ident.fields.channel, 6, (((uint16_t) (v[u].normalised * 16383.0)) >> 7) & 0x7F);
 				midi_tx(data->port, cc, ident.fields.channel, 38, ((uint16_t) (v[u].normalised * 16383.0)) & 0x7F);
 
 				if(!data->epn_tx_short){
diff --git a/backends/midi.md b/backends/midi.md
index 3ac011e..4732452 100644
--- a/backends/midi.md
+++ b/backends/midi.md
@@ -31,8 +31,8 @@ The MIDI backend supports mapping different MIDI events to MIDIMonster channels.
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
-* `rpn` - Registered parameter numbers (14bit extension)
-* `nrpn` - Non-registered parameter numbers (14bit extension)
+* `rpn` - Registered parameter numbers (14-bit extension)
+* `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
@@ -43,7 +43,7 @@ MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (n
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
 'channel aftertouch') and a pitch control which may all be mapped to individual MIDIMonster channels.
 
-Every channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
+Every MIDI channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
 the CC controls 101/100/99/98/38/6. Both control types have 14-bit IDs and 14-bit values.
 
 Example mappings:
diff --git a/backends/winmidi.c b/backends/winmidi.c
index 030062d..c89a098 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -82,7 +82,7 @@ static int winmidi_configure_instance(instance* inst, char* option, char* value)
 		data->read = strdup(value);
 		return 0;
 	}
-	if(!strcmp(option, "write")){
+	else if(!strcmp(option, "write")){
 		if(data->write){
 			LOGPF("Instance %s already connected to an output device", inst->name);
 			return 1;
@@ -90,6 +90,13 @@ static int winmidi_configure_instance(instance* inst, char* option, char* value)
 		data->write = strdup(value);
 		return 0;
 	}
+	else if(!strcmp(option, "epn-tx")){
+		data->epn_tx_short = 0;
+		if(!strcmp(value, "short")){
+			data->epn_tx_short = 1;
+		}
+		return 0;
+	}
 
 	LOGPF("Unknown instance configuration option %s on instance %s", option, inst->name);
 	return 1;
@@ -148,6 +155,14 @@ static channel* winmidi_channel(instance* inst, char* spec, uint8_t flags){
 		ident.fields.type = pressure;
 		next_token += 8;
 	}
+	else if(!strncmp(next_token, "rpn", 3)){
+		ident.fields.type = rpn;
+		next_token += 3;
+	}
+	else if(!strncmp(next_token, "nrpn", 4)){
+		ident.fields.type = nrpn;
+		next_token += 4;
+	}
 	else if(!strncmp(next_token, "pitch", 5)){
 		ident.fields.type = pitchbend;
 	}
@@ -167,11 +182,7 @@ static channel* winmidi_channel(instance* inst, char* spec, uint8_t flags){
 	return NULL;
 }
 
-static int winmidi_set(instance* inst, size_t num, channel** c, channel_value* v){
-	winmidi_instance_data* data = (winmidi_instance_data*) inst->impl;
-	winmidi_channel_ident ident = {
-		.label = 0
-	};
+static void winmidi_tx(HMIDIOUT port, uint8_t type, uint8_t channel, uint8_t control, uint16_t value){
 	union {
 		struct {
 			uint8_t status;
@@ -183,6 +194,28 @@ static int winmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 	} output = {
 		.dword = 0
 	};
+
+	output.components.status = type | channel;
+	output.components.data1 = control;
+	output.components.data2 = value;
+
+	if(type == pitchbend){
+		output.components.data1 = value & 0x7F;
+		output.components.data2 = (value >> 7) & 0x7F;
+	}
+	else if(type == aftertouch){
+		output.components.data1 = value;
+		output.components.data2 = 0;
+	}
+
+	midiOutShortMsg(port, output.dword);
+}
+
+static int winmidi_set(instance* inst, size_t num, channel** c, channel_value* v){
+	winmidi_instance_data* data = (winmidi_instance_data*) inst->impl;
+	winmidi_channel_ident ident = {
+		.label = 0
+	};
 	size_t u;
 
 	if(!data->device_out){
@@ -193,20 +226,29 @@ static int winmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 	for(u = 0; u < num; u++){
 		ident.label = c[u]->ident;
 
-		//build output message
-		output.components.status = ident.fields.type | ident.fields.channel;
-		output.components.data1 = ident.fields.control;
-		output.components.data2 = v[u].normalised * 127.0;
-		if(ident.fields.type == pitchbend){
-			output.components.data1 = ((int)(v[u].normalised * 16384.0)) & 0x7F;
-			output.components.data2 = (((int)(v[u].normalised * 16384.0)) >> 7) & 0x7F;
-		}
-		else if(ident.fields.type == aftertouch){
-			output.components.data1 = v[u].normalised * 127.0;
-			output.components.data2 = 0;
+		switch(ident.fields.type){
+			case rpn:
+			case nrpn:
+				//transmit parameter number
+				winmidi_tx(data->device_out, cc, ident.fields.channel, (ident.fields.type == rpn) ? 101 : 99, (ident.fields.control >> 7) & 0x7F);
+				winmidi_tx(data->device_out, cc, ident.fields.channel, (ident.fields.type == rpn) ? 100 : 98, ident.fields.control & 0x7F);
+
+				//transmit parameter value
+				winmidi_tx(data->device_out, cc, ident.fields.channel, 6, (((uint16_t) (v[u].normalised * 16383.0)) >> 7) & 0x7F);
+				winmidi_tx(data->device_out, cc, ident.fields.channel, 38, ((uint16_t) (v[u].normalised * 16383.0)) & 0x7F);
+
+				if(!data->epn_tx_short){
+					//clear active parameter
+					winmidi_tx(data->device_out, cc, ident.fields.channel, 101, 127);
+					winmidi_tx(data->device_out, cc, ident.fields.channel, 100, 127);
+				}
+				break;
+			case pitchbend:
+				winmidi_tx(data->device_out, ident.fields.type, ident.fields.channel, ident.fields.control, v[u].normalised * 16383.0);
+				break;
+			default:
+				winmidi_tx(data->device_out, ident.fields.type, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
 		}
-
-		midiOutShortMsg(data->device_out, output.dword);
 	}
 
 	return 0;
@@ -218,6 +260,10 @@ static char* winmidi_type_name(uint8_t typecode){
 			return "note";
 		case cc:
 			return "cc";
+		case rpn:
+			return "rpn";
+		case nrpn:
+			return "nrpn";
 		case pressure:
 			return "pressure";
 		case aftertouch:
@@ -295,6 +341,7 @@ static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DW
 	//callbacks may run on different threads, so we queue all events and alert the main thread via the feedback socket
 	DBGPF("Input callback on thread %ld", GetCurrentThreadId());
 
+	//TODO handle (n)rpn RX
 	switch(message){
 		case MIM_MOREDATA:
 			//processing too slow, do not immediately alert the main loop
diff --git a/backends/winmidi.h b/backends/winmidi.h
index 4c740ea..fbb2c94 100644
--- a/backends/winmidi.h
+++ b/backends/winmidi.h
@@ -13,6 +13,7 @@ static int winmidi_shutdown(size_t n, instance** inst);
 typedef struct /*_winmidi_instance_data*/ {
 	char* read;
 	char* write;
+	uint8_t epn_tx_short;
 	HMIDIIN device_in;
 	HMIDIOUT device_out;
 } winmidi_instance_data;
@@ -23,15 +24,17 @@ enum /*_winmidi_channel_type*/ {
 	cc = 0xB0,
 	pressure = 0xA0,
 	aftertouch = 0xD0,
-	pitchbend = 0xE0
+	pitchbend = 0xE0,
+	rpn = 0xF0,
+	nrpn = 0xF1
 };
 
 typedef union {
 	struct {
-		uint8_t pad[5];
+		uint8_t pad[4];
 		uint8_t type;
 		uint8_t channel;
-		uint8_t control;
+		uint16_t control;
 	} fields;
 	uint64_t label;
 } winmidi_channel_ident;
diff --git a/backends/winmidi.md b/backends/winmidi.md
index 25a6378..6b0fa98 100644
--- a/backends/winmidi.md
+++ b/backends/winmidi.md
@@ -19,6 +19,7 @@ some deviations may still be present.
 |---------------|-----------------------|-----------------------|-----------------------|
 | `read`	| `2`			| none			| MIDI device to connect for input |
 | `write`	| `DeviceName`		| none			| MIDI device to connect for output |
+| `epn-tx`	| `short`		| `full`		| Configure whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter. |
 
 Input/output device names may either be prefixes of MIDI device names or numeric indices corresponding
 to the listing shown at startup when using the global `list` option.
@@ -32,6 +33,8 @@ The `winmidi` backend supports mapping different MIDI events as MIDIMonster chan
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `rpn` - Registered parameter numbers (14-bit extension)
+* `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
@@ -42,16 +45,23 @@ MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (n
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
 'channel aftertouch') and a pitch control which may all be mapped to individual MIDIMonster channels.
 
+Every MIDI channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
+the CC controls 101/100/99/98/38/6. Both control types have 14-bit IDs and 14-bit values.
+
 Example mappings:
 ```
 midi1.ch0.note9 > midi2.channel1.cc4
 midi1.channel15.pressure1 > midi1.channel0.note0
 midi1.ch1.aftertouch > midi2.ch2.cc0
 midi1.ch0.pitch > midi2.ch1.pitch
+midi2.ch0.nrpn900 > midi1.ch1.rpn1
 ```
 
 #### Known bugs / problems
 
+Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
+received as such. Support for this functionality is planned.
+
 Currently, no Note Off messages are sent (instead, Note On messages with a velocity of 0 are
 generated, which amount to the same thing according to the spec). This may be implemented as
 a configuration option at a later time.
-- 
cgit v1.2.3


From 1e4a11bd9848c40e6cd19632bef1981bb33b3b3d Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 3 Jan 2021 18:12:48 +0100
Subject: Implement EPN transmission for the jack backend

---
 backends/jack.c  | 99 +++++++++++++++++++++++++++++++++++++++++---------------
 backends/jack.h  |  9 ++++--
 backends/jack.md |  7 ++++
 3 files changed, 86 insertions(+), 29 deletions(-)

diff --git a/backends/jack.c b/backends/jack.c
index c84ed0f..a3caf73 100644
--- a/backends/jack.c
+++ b/backends/jack.c
@@ -18,8 +18,6 @@
 	#endif
 #endif
 
-//FIXME pitchbend range is somewhat oob
-
 static struct /*_mmjack_backend_cfg*/ {
 	unsigned verbosity;
 	volatile sig_atomic_t jack_shutdown;
@@ -80,18 +78,42 @@ static int mmjack_midiqueue_append(mmjack_port* port, mmjack_channel_ident ident
 	return 0;
 }
 
+static void mmjack_process_midiout(void* buffer, size_t sample_offset, uint8_t type, uint8_t channel, uint8_t control, uint16_t value){
+	jack_midi_data_t* event_data = jack_midi_event_reserve(buffer, sample_offset, (type == midi_aftertouch) ? 2 : 3);
+
+	if(!event_data){
+		LOG("Failed to reserve MIDI stream data");
+		return;
+	}
+
+	//build midi event
+	event_data[0] = channel | type;
+	event_data[1] = control & 0x7F;
+	event_data[2] = value & 0x7F;
+
+	if(type == midi_pitchbend){
+		event_data[1] = value & 0x7F;
+		event_data[2] = (value >> 7) & 0x7F;
+	}
+	else if(type == midi_aftertouch){
+		event_data[1] = value & 0x7F;
+		event_data[2] = 0;
+	}
+}
+
 static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes, size_t* mark){
+	mmjack_instance_data* data = (mmjack_instance_data*) inst->impl;
 	void* buffer = jack_port_get_buffer(port->port, nframes);
 	jack_nframes_t event_count = jack_midi_get_event_count(buffer);
 	jack_midi_event_t event;
-	jack_midi_data_t* event_data;
 	mmjack_channel_ident ident;
-	size_t u;
+	size_t u, frame;
 	uint16_t value;
 
 	if(port->input){
 		if(event_count){
 			DBGPF("Reading %u MIDI events from port %s", event_count, port->name);
+			//TODO (n)rpn RX
 			for(u = 0; u < event_count; u++){
 				ident.label = 0;
 				//read midi data from stream
@@ -124,30 +146,33 @@ static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes
 		//clear buffer
 		jack_midi_clear_buffer(buffer);
 
+		frame = 0;
 		for(u = 0; u < port->queue_len; u++){
-			//build midi event
 			ident.label = port->queue[u].ident.label;
-			event_data = jack_midi_event_reserve(buffer, u, (ident.fields.sub_type == midi_aftertouch) ? 2 : 3);
-			if(!event_data){
-				LOG("Failed to reserve MIDI stream data");
-				return 1;
-			}
-			event_data[0] = ident.fields.sub_channel | ident.fields.sub_type;
-			if(ident.fields.sub_type == midi_pitchbend){
-				event_data[1] = port->queue[u].raw & 0x7F;
-				event_data[2] = (port->queue[u].raw >> 7) & 0x7F;
-			}
-			else if(ident.fields.sub_type == midi_aftertouch){
-				event_data[1] = port->queue[u].raw & 0x7F;
+
+			if(ident.fields.sub_type == midi_rpn
+					|| ident.fields.sub_type == midi_nrpn){
+				//transmit parameter number
+				mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, (ident.fields.sub_type == midi_rpn) ? 101 : 99, (ident.fields.sub_control >> 7) & 0x7F);
+				mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, (ident.fields.sub_type == midi_rpn) ? 100 : 98, ident.fields.sub_control & 0x7F);
+
+				//transmit parameter value
+				mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, 6, (port->queue[u].raw >> 7) & 0x7F);
+				mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, 38, port->queue[u].raw & 0x7F);
+
+				if(!data->midi_epn_tx_short){
+					//clear active parameter
+					mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, 101, 127);
+					mmjack_process_midiout(buffer, frame++, midi_cc, ident.fields.sub_channel, 100, 127);
+				}
 			}
 			else{
-				event_data[1] = ident.fields.sub_control;
-				event_data[2] = port->queue[u].raw & 0x7F;
+				mmjack_process_midiout(buffer, frame++, ident.fields.sub_type, ident.fields.sub_channel, ident.fields.sub_control, port->queue[u].raw);
 			}
 		}
 
-		if(port->queue_len){
-			DBGPF("Wrote %" PRIsize_t " MIDI events to port %s", port->queue_len, port->name);
+		if(frame){
+			DBGPF("Wrote %" PRIsize_t " MIDI events to port %s", frame, port->name);
 		}
 		port->queue_len = 0;
 	}
@@ -305,6 +330,13 @@ static int mmjack_configure_instance(instance* inst, char* option, char* value){
 		data->server_name = strdup(value);
 		return 0;
 	}
+	else if(!strcmp(option, "epn-tx")){
+		data->midi_epn_tx_short = 0;
+		if(!strcmp(value, "short")){
+			data->midi_epn_tx_short = 1;
+		}
+		return 0;
+	}
 
 	//register new port, first check for unique name
 	for(p = 0; p < data->ports; p++){
@@ -385,6 +417,14 @@ static int mmjack_parse_midispec(mmjack_channel_ident* ident, char* spec){
 		ident->fields.sub_type = midi_pressure;
 		next_token += 8;
 	}
+	else if(!strncmp(next_token, "rpn", 3)){
+		ident->fields.sub_type = midi_rpn;
+		next_token += 3;
+	}
+	else if(!strncmp(next_token, "nrpn", 4)){
+		ident->fields.sub_type = midi_nrpn;
+		next_token += 4;
+	}
 	else if(!strncmp(next_token, "pitch", 5)){
 		ident->fields.sub_type = midi_pitchbend;
 	}
@@ -399,7 +439,9 @@ static int mmjack_parse_midispec(mmjack_channel_ident* ident, char* spec){
 	ident->fields.sub_control = strtoul(next_token, NULL, 10);
 
 	if(ident->fields.sub_type == midi_none
-			|| ident->fields.sub_control > 127){
+			|| (ident->fields.sub_type != midi_nrpn
+				&& ident->fields.sub_type != midi_rpn
+				&& ident->fields.sub_control > 127)){
 		LOGPF("Invalid MIDI spec %s", spec);
 		return 1;
 	}
@@ -467,9 +509,12 @@ static int mmjack_set(instance* inst, size_t num, channel** c, channel_value* v)
 				break;
 			case port_midi:
 				value = v[u].normalised * 127.0;
-				if(ident.fields.sub_type == midi_pitchbend){
-					value = ((uint16_t)(v[u].normalised * 16384.0));
+				if(ident.fields.sub_type == midi_pitchbend
+						|| ident.fields.sub_type == midi_nrpn
+						|| ident.fields.sub_type == midi_rpn){
+					value = ((uint16_t)(v[u].normalised * 16383.0));
 				}
+
 				if(mmjack_midiqueue_append(data->port + ident.fields.port, ident, value)){
 					pthread_mutex_unlock(&data->port[ident.fields.port].lock);
 					return 1;
@@ -494,8 +539,10 @@ static void mmjack_handle_midi(instance* inst, size_t index, mmjack_port* port){
 		port->queue[u].ident.fields.port = index;
 		chan = mm_channel(inst, port->queue[u].ident.label, 0);
 		if(chan){
-			if(port->queue[u].ident.fields.sub_type == midi_pitchbend){
-				val.normalised = ((double)port->queue[u].raw) / 16384.0;
+			if(port->queue[u].ident.fields.sub_type == midi_pitchbend
+					|| port->queue[u].ident.fields.sub_type == midi_rpn
+					|| port->queue[u].ident.fields.sub_type == midi_nrpn){
+				val.normalised = ((double)port->queue[u].raw) / 16383.0;
 			}
 			else{
 				val.normalised = ((double)port->queue[u].raw) / 127.0;
diff --git a/backends/jack.h b/backends/jack.h
index 03ce052..ca62ea5 100644
--- a/backends/jack.h
+++ b/backends/jack.h
@@ -22,16 +22,17 @@ enum /*mmjack_midi_channel_type*/ {
 	midi_cc = 0xB0,
 	midi_pressure = 0xA0,
 	midi_aftertouch = 0xD0,
-	midi_pitchbend = 0xE0
+	midi_pitchbend = 0xE0,
+	midi_rpn = 0xF0,
+	midi_nrpn = 0xF1
 };
 
 typedef union {
 	struct {
 		uint32_t port;
-		uint8_t pad;
 		uint8_t sub_type;
 		uint8_t sub_channel;
-		uint8_t sub_control;
+		uint16_t sub_control;
 	} fields;
 	uint64_t label;
 } mmjack_channel_ident;
@@ -70,6 +71,8 @@ typedef struct /*_jack_instance_data*/ {
 	char* client_name;
 	int fd;
 
+	uint8_t midi_epn_tx_short;
+
 	jack_client_t* client;
 	size_t ports;
 	mmjack_port* port;
diff --git a/backends/jack.md b/backends/jack.md
index b6ff5a9..3d426f3 100644
--- a/backends/jack.md
+++ b/backends/jack.md
@@ -16,6 +16,7 @@ transport of control data via either JACK midi ports or control voltage (CV) inp
 |---------------|-----------------------|-----------------------|-----------------------|
 | `name`	| `Controller`		| `MIDIMonster`		| Client name for the JACK connection |
 | `server`	| `jackserver`		| `default`		| JACK server identifier to connect to |
+| `epn-tx`	| `short`		| `full`		| Configure whether to clear the active parameter number after transmitting a MIDI `nrpn` or `rpn` parameter. |
 
 Channels (corresponding to JACK ports) need to be configured with their type and, if applicable, value limits.
 To configure a port, specify it in the instance configuration using the following syntax:
@@ -65,6 +66,8 @@ The following values are recognized for `type`:
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `rpn` - Registered parameter numbers (14-bit extension)
+* `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 The `pitch` and `aftertouch` events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
 
@@ -72,6 +75,7 @@ Example mappings:
 ```
 jack1.cv_in > jack1.midi_out.ch0.note3
 jack1.midi_in.ch0.pitch > jack1.cv_out
+jack2.midi_in.ch0.nrpn900 > jack1.midi_out.ch1.rpn1
 ```
 
 The MIDI subchannel syntax is intentionally kept compatible to the different MIDI backends also supported
@@ -79,6 +83,9 @@ by the MIDIMonster
 
 #### Known bugs / problems
 
+Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
+received as such. Support for this functionality is planned.
+
 While JACK has rudimentary capabilities for transporting OSC messages, configuring and parsing such channels
 with this backend would take a great amount of dedicated syntax & code. CV ports can provide fine-grained single
 control channels as an alternative to MIDI. This feature may be implemented at some point in the future.
-- 
cgit v1.2.3


From 50ce7276315671b72ecbfbcb7bebe6d34654639a Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Mon, 4 Jan 2021 01:16:28 +0100
Subject: Implement EPN reception for the midi backend

---
 backends/midi.c  | 105 ++++++++++++++++++++++++++++++++++++++++++++++++++-----
 backends/midi.h  |  10 ++++--
 backends/midi.md |   7 ++--
 3 files changed, 110 insertions(+), 12 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index d581a01..7883662 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -273,11 +273,91 @@ static char* midi_type_name(uint8_t type){
 	return "unknown";
 }
 
+static void midi_handle_epn(instance* inst, uint8_t chan, uint16_t control, uint16_t value){
+	midi_instance_data* data = (midi_instance_data*) inst->impl;
+	midi_channel_ident ident = {
+		.label = 0
+	};
+	channel* changed = NULL;
+	channel_value val;
+	//check for 3-byte update TODO
+
+	//switching between nrpn and rpn clears all valid bits
+	if(((data->epn_status[chan] & EPN_NRPN) && (control == 101 || control == 100))
+				|| (!(data->epn_status[chan] & EPN_NRPN) && (control == 99 || control == 98))){
+		data->epn_status[chan] &= ~(EPN_NRPN | EPN_PARAMETER_LO | EPN_PARAMETER_HI);
+	}
+
+	//setting an address always invalidates the value valid bits
+	if(control >= 98 && control <= 101){
+		data->epn_status[chan] &= ~(EPN_VALUE_HI /*| EPN_VALUE_LO*/);
+	}
+
+	//parameter hi
+	if(control == 101 || control == 99){
+		data->epn_control[chan] &= 0x7F;
+		data->epn_control[chan] |= value << 7;
+		data->epn_status[chan] |= EPN_PARAMETER_HI | ((control == 99) ? EPN_NRPN : 0);
+		if(control == 101 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_HI;
+		}
+	}
+
+	//parameter lo
+	if(control == 100 || control == 98){
+		data->epn_control[chan] &= ~0x7F;
+		data->epn_control[chan] |= value & 0x7F;
+		data->epn_status[chan] |= EPN_PARAMETER_LO | ((control == 98) ? EPN_NRPN : 0);
+		if(control == 100 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_LO;
+		}
+	}
+
+	//value hi, clears low, mark as update candidate
+	if(control == 6
+			//check if parameter is set before accepting value update
+			&& ((data->epn_status[chan] & (EPN_PARAMETER_HI | EPN_PARAMETER_LO)) == (EPN_PARAMETER_HI | EPN_PARAMETER_LO))){
+		data->epn_value[chan] = value << 7;
+		data->epn_status[chan] |= EPN_VALUE_HI;
+	}
+
+	//FIXME is the update order for the value bits fixed?
+	//FIXME can there be standalone updates on CC 38?
+
+	//value lo, flush the value
+	if(control == 38
+			&& data->epn_status[chan] & EPN_VALUE_HI){
+		data->epn_value[chan] &= ~0x7F;
+		data->epn_value[chan] |= value & 0x7F;
+		//FIXME not clearing the valid bit would allow for fast low-order updates
+		data->epn_status[chan] &= ~EPN_VALUE_HI;
+
+		if(midi_config.detect){
+			LOGPF("Incoming EPN data on channel %s.ch%d.%s%d", inst->name, chan, data->epn_status[chan] & EPN_NRPN ? "nrpn" : "rpn", data->epn_control[chan]);
+		}
+
+		//find the updated channel
+		ident.fields.type = data->epn_status[chan] & EPN_NRPN ? nrpn : rpn;
+		ident.fields.channel = chan;
+		ident.fields.control = data->epn_control[chan];
+		val.normalised = (double) data->epn_value[chan] / 16383.0;
+
+		//push the new value
+		changed = mm_channel(inst, ident.label, 0);
+		if(changed){
+			mm_channel_event(changed, val);
+		}
+	}
+}
+
 static int midi_handle(size_t num, managed_fd* fds){
 	snd_seq_event_t* ev = NULL;
 	instance* inst = NULL;
+	midi_instance_data* data = NULL;
+
 	channel* changed = NULL;
 	channel_value val;
+
 	char* event_type = NULL;
 	midi_channel_ident ident = {
 		.label = 0
@@ -295,7 +375,14 @@ static int midi_handle(size_t num, managed_fd* fds){
 		ident.fields.control = ev->data.note.note;
 		val.normalised = (double) ev->data.note.velocity / 127.0;
 
-		//TODO (n)rpn RX
+		//scan for the instance before parsing incoming data, instance state is required for the EPN state machine
+		inst = mm_instance_find(BACKEND_NAME, ev->dest.port);
+		if(!inst){
+			LOG("Delivered event did not match any instance");
+			continue;
+		}
+		data = (midi_instance_data*) inst->impl;
+
 		switch(ev->type){
 			case SND_SEQ_EVENT_NOTEON:
 			case SND_SEQ_EVENT_NOTEOFF:
@@ -323,6 +410,15 @@ static int midi_handle(size_t num, managed_fd* fds){
 				ident.fields.channel = ev->data.control.channel;
 				ident.fields.control = ev->data.control.param;
 				val.normalised = (double) ev->data.control.value / 127.0;
+
+				//check for EPN CCs and update the state machine
+				if((ident.fields.control <= 101 && ident.fields.control >= 98)
+						|| ident.fields.control == 6
+						|| ident.fields.control == 38
+						//if the high-order value bits are set, forward any control to the state machine for the short update form
+						|| data->epn_status[ident.fields.channel] & EPN_VALUE_HI){
+					midi_handle_epn(inst, ident.fields.channel, ident.fields.control, ev->data.control.value);
+				}
 				break;
 			default:
 				LOG("Ignored event of unsupported type");
@@ -330,13 +426,6 @@ static int midi_handle(size_t num, managed_fd* fds){
 		}
 
 		event_type = midi_type_name(ident.fields.type);
-		inst = mm_instance_find(BACKEND_NAME, ev->dest.port);
-		if(!inst){
-			//FIXME might want to return failure
-			LOG("Delivered event did not match any instance");
-			continue;
-		}
-
 		changed = mm_channel(inst, ident.label, 0);
 		if(changed){
 			if(mm_channel_event(changed, val)){
diff --git a/backends/midi.h b/backends/midi.h
index 4e2ac09..51b4a30 100644
--- a/backends/midi.h
+++ b/backends/midi.h
@@ -10,14 +10,20 @@ static int midi_handle(size_t num, managed_fd* fds);
 static int midi_start(size_t n, instance** inst);
 static int midi_shutdown(size_t n, instance** inst);
 
+#define EPN_NRPN 8
+#define EPN_PARAMETER_HI 4
+#define EPN_PARAMETER_LO 2
+#define EPN_VALUE_HI 1
+
 typedef struct /*_midi_instance_data*/ {
 	int port;
 	char* read;
 	char* write;
 	uint8_t epn_tx_short;
 
-	uint16_t epn_control;
-	uint16_t epn_value;
+	uint16_t epn_control[16];
+	uint16_t epn_value[16];
+	uint8_t epn_status[16];
 } midi_instance_data;
 
 typedef union {
diff --git a/backends/midi.md b/backends/midi.md
index 4732452..87d06a1 100644
--- a/backends/midi.md
+++ b/backends/midi.md
@@ -56,8 +56,11 @@ midi1.ch0.nrpn900 > midi2.ch0.rpn1
 ```
 #### Known bugs / problems
 
-Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
-received as such. Support for this functionality is planned.
+Extended parameter numbers (EPNs, the `rpn` and `nrpn` control types) will also generate events on the controls (CC 101 through
+98, 38 and 6) that are used as the lower layer transport. When using EPNs, mapping those controls is probably not useful.
+
+EPN control types support only the full 14-bit transfer encoding, not the shorter variant transmitting only the 7
+high-order bits. This may be changed if there is sufficient interest in the functionality.
 
 To access MIDI data, the user running MIDIMonster needs read & write access to the ALSA sequencer.
 This can usually be done by adding this user to the `audio` system group.
-- 
cgit v1.2.3


From 41cb85a842a696e1183e1d55116c99b63099fde3 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 8 Jan 2021 21:38:43 +0100
Subject: Implement EPN reception for the winmidi backend

---
 backends/midi.c     |   2 +
 backends/midi.h     |   2 +-
 backends/winmidi.c  | 123 +++++++++++++++++++++++++++++++++++++++++++---------
 backends/winmidi.h  |  10 +++++
 backends/winmidi.md |   7 ++-
 5 files changed, 121 insertions(+), 23 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index 7883662..bddabb5 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -273,6 +273,7 @@ static char* midi_type_name(uint8_t type){
 	return "unknown";
 }
 
+//this state machine is used more-or-less verbatim in the winmidi and jack backends - fixes need to be applied there, too
 static void midi_handle_epn(instance* inst, uint8_t chan, uint16_t control, uint16_t value){
 	midi_instance_data* data = (midi_instance_data*) inst->impl;
 	midi_channel_ident ident = {
@@ -402,6 +403,7 @@ static int midi_handle(size_t num, managed_fd* fds){
 				break;
 			case SND_SEQ_EVENT_PITCHBEND:
 				ident.fields.type = pitchbend;
+				ident.fields.control = 0;
 				ident.fields.channel = ev->data.control.channel;
 				val.normalised = ((double) ev->data.control.value + 8192) / 16383.0;
 				break;
diff --git a/backends/midi.h b/backends/midi.h
index 51b4a30..e2d6543 100644
--- a/backends/midi.h
+++ b/backends/midi.h
@@ -19,8 +19,8 @@ typedef struct /*_midi_instance_data*/ {
 	int port;
 	char* read;
 	char* write;
-	uint8_t epn_tx_short;
 
+	uint8_t epn_tx_short;
 	uint16_t epn_control[16];
 	uint16_t epn_value[16];
 	uint8_t epn_status[16];
diff --git a/backends/winmidi.c b/backends/winmidi.c
index c89a098..66456e8 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -321,11 +321,98 @@ static int winmidi_handle(size_t num, managed_fd* fds){
 	return 0;
 }
 
-static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DWORD_PTR inst, DWORD param1, DWORD param2){
+static int winmidi_enqueue_input(instance* inst, winmidi_channel_ident ident, channel_value val){
+	EnterCriticalSection(&backend_config.push_events);
+	if(backend_config.events_alloc <= backend_config.events_active){
+		backend_config.event = realloc((void*) backend_config.event, (backend_config.events_alloc + 1) * sizeof(winmidi_event));
+		if(!backend_config.event){
+			LOG("Failed to allocate memory");
+			backend_config.events_alloc = 0;
+			backend_config.events_active = 0;
+			LeaveCriticalSection(&backend_config.push_events);
+			return 1;
+		}
+		backend_config.events_alloc++;
+	}
+	backend_config.event[backend_config.events_active].inst = inst;
+	backend_config.event[backend_config.events_active].channel.label = ident.label;
+	backend_config.event[backend_config.events_active].value = val;
+	backend_config.events_active++;
+	LeaveCriticalSection(&backend_config.push_events);
+	return 0;
+}
+
+//this state machine was copied more-or-less verbatim from the alsa midi implementation - fixes there will need to be integrated
+static void winmidi_handle_epn(instance* inst, uint8_t chan, uint16_t control, uint16_t value){
+	winmidi_instance_data* data = (winmidi_instance_data*) inst->impl;
 	winmidi_channel_ident ident = {
 		.label = 0
 	};
 	channel_value val;
+
+	//switching between nrpn and rpn clears all valid bits
+	if(((data->epn_status[chan] & EPN_NRPN) && (control == 101 || control == 100))
+				|| (!(data->epn_status[chan] & EPN_NRPN) && (control == 99 || control == 98))){
+		data->epn_status[chan] &= ~(EPN_NRPN | EPN_PARAMETER_LO | EPN_PARAMETER_HI);
+	}
+
+	//setting an address always invalidates the value valid bits
+	if(control >= 98 && control <= 101){
+		data->epn_status[chan] &= ~EPN_VALUE_HI;
+	}
+
+	//parameter hi
+	if(control == 101 || control == 99){
+		data->epn_control[chan] &= 0x7F;
+		data->epn_control[chan] |= value << 7;
+		data->epn_status[chan] |= EPN_PARAMETER_HI | ((control == 99) ? EPN_NRPN : 0);
+		if(control == 101 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_HI;
+		}
+	}
+
+	//parameter lo
+	if(control == 100 || control == 98){
+		data->epn_control[chan] &= ~0x7F;
+		data->epn_control[chan] |= value & 0x7F;
+		data->epn_status[chan] |= EPN_PARAMETER_LO | ((control == 98) ? EPN_NRPN : 0);
+		if(control == 100 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_LO;
+		}
+	}
+
+	//value hi, clears low, mark as update candidate
+	if(control == 6
+			//check if parameter is set before accepting value update
+			&& ((data->epn_status[chan] & (EPN_PARAMETER_HI | EPN_PARAMETER_LO)) == (EPN_PARAMETER_HI | EPN_PARAMETER_LO))){
+		data->epn_value[chan] = value << 7;
+		data->epn_status[chan] |= EPN_VALUE_HI;
+	}
+
+	//value lo, flush the value
+	if(control == 38
+			&& data->epn_status[chan] & EPN_VALUE_HI){
+		data->epn_value[chan] &= ~0x7F;
+		data->epn_value[chan] |= value & 0x7F;
+		data->epn_status[chan] &= ~EPN_VALUE_HI;
+
+		//find the updated channel
+		ident.fields.type = data->epn_status[chan] & EPN_NRPN ? nrpn : rpn;
+		ident.fields.channel = chan;
+		ident.fields.control = data->epn_control[chan];
+		val.normalised = (double) data->epn_value[chan] / 16383.0;
+
+		winmidi_enqueue_input(inst, ident,val);
+	}
+}
+
+static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DWORD_PTR inst, DWORD param1, DWORD param2){
+	winmidi_channel_ident ident = {
+		.label = 0
+	};
+	channel_value val = {
+		0
+	};
 	union {
 		struct {
 			uint8_t status;
@@ -341,7 +428,6 @@ static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DW
 	//callbacks may run on different threads, so we queue all events and alert the main thread via the feedback socket
 	DBGPF("Input callback on thread %ld", GetCurrentThreadId());
 
-	//TODO handle (n)rpn RX
 	switch(message){
 		case MIM_MOREDATA:
 			//processing too slow, do not immediately alert the main loop
@@ -352,18 +438,22 @@ static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DW
 			ident.fields.type = input.components.status & 0xF0;
 			ident.fields.control = input.components.data1;
 			val.normalised = (double) input.components.data2 / 127.0;
+			val.raw.u64 = input.components.data2;
 
 			if(ident.fields.type == 0x80){
 				ident.fields.type = note;
 				val.normalised = 0;
+				val.raw.u64 = 0;
 			}
 			else if(ident.fields.type == pitchbend){
 				ident.fields.control = 0;
-				val.normalised = (double)((input.components.data2 << 7) | input.components.data1) / 16384.0;
+				val.normalised = (double) ((input.components.data2 << 7) | input.components.data1) / 16383.0;
+				val.raw.u64 = input.components.data2 << 7 | input.components.data1;
 			}
 			else if(ident.fields.type == aftertouch){
 				ident.fields.control = 0;
 				val.normalised = (double) input.components.data1 / 127.0;
+				val.raw.u64 = input.components.data1;
 			}
 			break;
 		case MIM_LONGDATA:
@@ -379,26 +469,19 @@ static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DW
 			return;
 	}
 
+	//pass changes in the (n)rpn CCs to the EPN state machine
+	if(ident.fields.type == cc
+			&& ((ident.fields.control <= 101 && ident.fields.control >= 98)
+				|| ident.fields.control == 6
+				|| ident.fields.control == 38)){
+		winmidi_handle_epn((instance*) inst, ident.fields.channel, ident.fields.control, val.raw.u64);
+	}
+
 	DBGPF("Incoming message type %d channel %d control %d value %f",
 			ident.fields.type, ident.fields.channel, ident.fields.control, val.normalised);
-
-	EnterCriticalSection(&backend_config.push_events);
-	if(backend_config.events_alloc <= backend_config.events_active){
-		backend_config.event = realloc((void*) backend_config.event, (backend_config.events_alloc + 1) * sizeof(winmidi_event));
-		if(!backend_config.event){
-			LOG("Failed to allocate memory");
-			backend_config.events_alloc = 0;
-			backend_config.events_active = 0;
-			LeaveCriticalSection(&backend_config.push_events);
-			return;
-		}
-		backend_config.events_alloc++;
+	if(winmidi_enqueue_input((instance*) inst, ident, val)){
+		LOG("Failed to enqueue incoming data");
 	}
-	backend_config.event[backend_config.events_active].inst = (instance*) inst;
-	backend_config.event[backend_config.events_active].channel.label = ident.label;
-	backend_config.event[backend_config.events_active].value = val;
-	backend_config.events_active++;
-	LeaveCriticalSection(&backend_config.push_events);
 
 	if(message != MIM_MOREDATA){
 		//alert the main loop
diff --git a/backends/winmidi.h b/backends/winmidi.h
index fbb2c94..4d3e2dd 100644
--- a/backends/winmidi.h
+++ b/backends/winmidi.h
@@ -10,10 +10,20 @@ static int winmidi_handle(size_t num, managed_fd* fds);
 static int winmidi_start(size_t n, instance** inst);
 static int winmidi_shutdown(size_t n, instance** inst);
 
+#define EPN_NRPN 8
+#define EPN_PARAMETER_HI 4
+#define EPN_PARAMETER_LO 2
+#define EPN_VALUE_HI 1
+
 typedef struct /*_winmidi_instance_data*/ {
 	char* read;
 	char* write;
+	
 	uint8_t epn_tx_short;
+	uint16_t epn_control[16];
+	uint16_t epn_value[16];
+	uint8_t epn_status[16];
+
 	HMIDIIN device_in;
 	HMIDIOUT device_out;
 } winmidi_instance_data;
diff --git a/backends/winmidi.md b/backends/winmidi.md
index 6b0fa98..be14424 100644
--- a/backends/winmidi.md
+++ b/backends/winmidi.md
@@ -59,8 +59,11 @@ midi2.ch0.nrpn900 > midi1.ch1.rpn1
 
 #### Known bugs / problems
 
-Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
-received as such. Support for this functionality is planned.
+Extended parameter numbers (EPNs, the `rpn` and `nrpn` control types) will also generate events on the controls (CC 101 through
+98, 38 and 6) that are used as the lower layer transport. When using EPNs, mapping those controls is probably not useful.
+
+EPN control types support only the full 14-bit transfer encoding, not the shorter variant transmitting only the 7
+high-order bits. This may be changed if there is sufficient interest in the functionality.
 
 Currently, no Note Off messages are sent (instead, Note On messages with a velocity of 0 are
 generated, which amount to the same thing according to the spec). This may be implemented as
-- 
cgit v1.2.3


From 00ba26c238a2e75c5b7d2e32469eae02179efde9 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 8 Jan 2021 23:03:11 +0100
Subject: Implement EPN reception for the jack backend

---
 TODO               |  1 +
 backends/jack.c    | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 backends/jack.h    | 10 ++++++++
 backends/jack.md   |  7 ++++--
 backends/winmidi.c |  2 +-
 5 files changed, 88 insertions(+), 4 deletions(-)

diff --git a/TODO b/TODO
index 5662479..2ab5f10 100644
--- a/TODO
+++ b/TODO
@@ -5,6 +5,7 @@ make event collectors threadsafe to stop marshalling data...
 collect & check backend API version
 move all connection establishment to _start to be able to hot-stop/start all backends
 event deduplication in core?
+move all typenames to _t
 
 per-channel filters
 	* invert
diff --git a/backends/jack.c b/backends/jack.c
index a3caf73..176144f 100644
--- a/backends/jack.c
+++ b/backends/jack.c
@@ -101,6 +101,68 @@ static void mmjack_process_midiout(void* buffer, size_t sample_offset, uint8_t t
 	}
 }
 
+//this state machine was copied more-or-less verbatim from the alsa midi implementation - fixes there will need to be integrated
+static void mmjack_handle_epn(mmjack_port* port, uint8_t chan, uint16_t control, uint16_t value){
+	mmjack_channel_ident ident = {
+		.label = 0
+	};
+
+	//switching between nrpn and rpn clears all valid bits
+	if(((port->epn_status[chan] & EPN_NRPN) && (control == 101 || control == 100))
+				|| (!(port->epn_status[chan] & EPN_NRPN) && (control == 99 || control == 98))){
+		port->epn_status[chan] &= ~(EPN_NRPN | EPN_PARAMETER_LO | EPN_PARAMETER_HI);
+	}
+
+	//setting an address always invalidates the value valid bits
+	if(control >= 98 && control <= 101){
+		port->epn_status[chan] &= ~EPN_VALUE_HI;
+	}
+
+	//parameter hi
+	if(control == 101 || control == 99){
+		port->epn_control[chan] &= 0x7F;
+		port->epn_control[chan] |= value << 7;
+		port->epn_status[chan] |= EPN_PARAMETER_HI | ((control == 99) ? EPN_NRPN : 0);
+		if(control == 101 && value == 127){
+			port->epn_status[chan] &= ~EPN_PARAMETER_HI;
+		}
+	}
+
+	//parameter lo
+	if(control == 100 || control == 98){
+		port->epn_control[chan] &= ~0x7F;
+		port->epn_control[chan] |= value & 0x7F;
+		port->epn_status[chan] |= EPN_PARAMETER_LO | ((control == 98) ? EPN_NRPN : 0);
+		if(control == 100 && value == 127){
+			port->epn_status[chan] &= ~EPN_PARAMETER_LO;
+		}
+	}
+
+	//value hi, clears low, mark as update candidate
+	if(control == 6
+			//check if parameter is set before accepting value update
+			&& ((port->epn_status[chan] & (EPN_PARAMETER_HI | EPN_PARAMETER_LO)) == (EPN_PARAMETER_HI | EPN_PARAMETER_LO))){
+		port->epn_value[chan] = value << 7;
+		port->epn_status[chan] |= EPN_VALUE_HI;
+	}
+
+	//value lo, flush the value
+	if(control == 38
+			&& port->epn_status[chan] & EPN_VALUE_HI){
+		port->epn_value[chan] &= ~0x7F;
+		port->epn_value[chan] |= value & 0x7F;
+		port->epn_status[chan] &= ~EPN_VALUE_HI;
+
+		//find the updated channel
+		ident.fields.sub_type = port->epn_status[chan] & EPN_NRPN ? midi_nrpn : midi_rpn;
+		ident.fields.sub_channel = chan;
+		ident.fields.sub_control = port->epn_control[chan];
+
+		//ident.fields.port set on output in mmjack_handle_midi
+		mmjack_midiqueue_append(port, ident, port->epn_value[chan]);
+	}
+}
+
 static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes, size_t* mark){
 	mmjack_instance_data* data = (mmjack_instance_data*) inst->impl;
 	void* buffer = jack_port_get_buffer(port->port, nframes);
@@ -113,7 +175,6 @@ static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes
 	if(port->input){
 		if(event_count){
 			DBGPF("Reading %u MIDI events from port %s", event_count, port->name);
-			//TODO (n)rpn RX
 			for(u = 0; u < event_count; u++){
 				ident.label = 0;
 				//read midi data from stream
@@ -135,6 +196,15 @@ static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes
 					ident.fields.sub_control = 0;
 					value = event.buffer[1];
 				}
+
+				//forward the EPN CCs to the EPN state machine
+				if(ident.fields.sub_type == midi_cc
+						&& ((ident.fields.sub_control <= 101 && ident.fields.sub_control >= 98)
+							|| ident.fields.sub_control == 6
+							|| ident.fields.sub_control == 38)){
+					mmjack_handle_epn(port, ident.fields.sub_channel, ident.fields.sub_control, value);
+				}
+
 				//append midi data
 				mmjack_midiqueue_append(port, ident, value);
 			}
diff --git a/backends/jack.h b/backends/jack.h
index ca62ea5..762282b 100644
--- a/backends/jack.h
+++ b/backends/jack.h
@@ -16,6 +16,11 @@ static int mmjack_shutdown(size_t n, instance** inst);
 #define JACK_DEFAULT_SERVER_NAME "default"
 #define JACK_MIDIQUEUE_CHUNK 10
 
+#define EPN_NRPN 8
+#define EPN_PARAMETER_HI 4
+#define EPN_PARAMETER_LO 2
+#define EPN_VALUE_HI 1
+
 enum /*mmjack_midi_channel_type*/ {
 	midi_none = 0,
 	midi_note = 0x90,
@@ -59,10 +64,15 @@ typedef struct /*_mmjack_port_data*/ {
 	double min;
 	uint8_t mark;
 	double last;
+
 	size_t queue_len;
 	size_t queue_alloc;
 	mmjack_midiqueue* queue;
 
+	uint16_t epn_control[16];
+	uint16_t epn_value[16];
+	uint8_t epn_status[16];
+
 	pthread_mutex_t lock;
 } mmjack_port;
 
diff --git a/backends/jack.md b/backends/jack.md
index 3d426f3..4ff77f6 100644
--- a/backends/jack.md
+++ b/backends/jack.md
@@ -83,8 +83,11 @@ by the MIDIMonster
 
 #### Known bugs / problems
 
-Extended parameter numbers (`rpn` and `nrpn` control types) can currently only be transmitted, not properly
-received as such. Support for this functionality is planned.
+MIDI extended parameter numbers (EPNs, the `rpn` and `nrpn` control types) will also generate events on the controls (CC 101 through
+98, 38 and 6) that are used as the lower layer transport. When using EPNs, mapping those controls is probably not useful.
+
+EPN control types support only the full 14-bit transfer encoding, not the shorter variant transmitting only the 7
+high-order bits. This may be changed if there is sufficient interest in the functionality.
 
 While JACK has rudimentary capabilities for transporting OSC messages, configuring and parsing such channels
 with this backend would take a great amount of dedicated syntax & code. CV ports can provide fine-grained single
diff --git a/backends/winmidi.c b/backends/winmidi.c
index 66456e8..d12dc71 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -402,7 +402,7 @@ static void winmidi_handle_epn(instance* inst, uint8_t chan, uint16_t control, u
 		ident.fields.control = data->epn_control[chan];
 		val.normalised = (double) data->epn_value[chan] / 16383.0;
 
-		winmidi_enqueue_input(inst, ident,val);
+		winmidi_enqueue_input(inst, ident, val);
 	}
 }
 
-- 
cgit v1.2.3


From 7902842bd10b17d8d5b6bfc586f440299646d48c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 9 Jan 2021 15:21:24 +0100
Subject: Add source/target as aliases for MIDI read/write config options (#79)

---
 backends/midi.c     |  4 ++--
 backends/midi.md    | 10 +++++-----
 backends/winmidi.c  |  4 ++--
 backends/winmidi.md | 10 +++++-----
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index bddabb5..e32c975 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -83,7 +83,7 @@ static int midi_configure_instance(instance* inst, char* option, char* value){
 	midi_instance_data* data = (midi_instance_data*) inst->impl;
 
 	//FIXME maybe allow connecting more than one device
-	if(!strcmp(option, "read")){
+	if(!strcmp(option, "read") || !strcmp(option, "source")){
 		//connect input device
 		if(data->read){
 			LOGPF("Instance %s was already connected to an input device", inst->name);
@@ -92,7 +92,7 @@ static int midi_configure_instance(instance* inst, char* option, char* value){
 		data->read = strdup(value);
 		return 0;
 	}
-	else if(!strcmp(option, "write")){
+	else if(!strcmp(option, "write") || !strcmp(option, "target")){
 		//connect output device
 		if(data->write){
 			LOGPF("Instance %s was already connected to an output device", inst->name);
diff --git a/backends/midi.md b/backends/midi.md
index 87d06a1..60a4d06 100644
--- a/backends/midi.md
+++ b/backends/midi.md
@@ -11,11 +11,11 @@ The MIDI backend provides read-write access to the MIDI protocol via virtual por
 
 #### Instance configuration
 
-| Option	| Example value		| Default value 	| Description		|
-|---------------|-----------------------|-----------------------|-----------------------|
-| `read`	| `20:0`		| none			| MIDI device to connect for input |
-| `write`	| `DeviceName`		| none			| MIDI device to connect for output |
-| `epn-tx`	| `short`		| `full`		| Configures whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter |
+| Option		| Example value		| Default value 	| Description		|
+|-----------------------|-----------------------|-----------------------|-----------------------|
+| `read` / `source`	| `20:0`		| none			| MIDI device to connect for input |
+| `write` / `target`	| `DeviceName`		| none			| MIDI device to connect for output |
+| `epn-tx`		| `short`		| `full`		| Configures whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter |
 
 MIDI device names may either be `client:port` portnames or prefixes of MIDI device names.
 Run `aconnect -i` to list input ports and `aconnect -o` to list output ports.
diff --git a/backends/winmidi.c b/backends/winmidi.c
index d12dc71..ec0fb44 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -74,7 +74,7 @@ static int winmidi_configure(char* option, char* value){
 
 static int winmidi_configure_instance(instance* inst, char* option, char* value){
 	winmidi_instance_data* data = (winmidi_instance_data*) inst->impl;
-	if(!strcmp(option, "read")){
+	if(!strcmp(option, "read") || !strcmp(option, "source")){
 		if(data->read){
 			LOGPF("Instance %s already connected to an input device", inst->name);
 			return 1;
@@ -82,7 +82,7 @@ static int winmidi_configure_instance(instance* inst, char* option, char* value)
 		data->read = strdup(value);
 		return 0;
 	}
-	else if(!strcmp(option, "write")){
+	else if(!strcmp(option, "write") || !strcmp(option, "target")){
 		if(data->write){
 			LOGPF("Instance %s already connected to an output device", inst->name);
 			return 1;
diff --git a/backends/winmidi.md b/backends/winmidi.md
index be14424..4de792a 100644
--- a/backends/winmidi.md
+++ b/backends/winmidi.md
@@ -15,11 +15,11 @@ some deviations may still be present.
 
 #### Instance configuration
 
-| Option	| Example value		| Default value 	| Description		|
-|---------------|-----------------------|-----------------------|-----------------------|
-| `read`	| `2`			| none			| MIDI device to connect for input |
-| `write`	| `DeviceName`		| none			| MIDI device to connect for output |
-| `epn-tx`	| `short`		| `full`		| Configure whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter. |
+| Option		| Example value		| Default value 	| Description		|
+|-----------------------|-----------------------|-----------------------|-----------------------|
+| `read` / `source`	| `2`			| none			| MIDI device to connect for input |
+| `write` / `target`	| `DeviceName`		| none			| MIDI device to connect for output |
+| `epn-tx`		| `short`		| `full`		| Configure whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter. |
 
 Input/output device names may either be prefixes of MIDI device names or numeric indices corresponding
 to the listing shown at startup when using the global `list` option.
-- 
cgit v1.2.3


From a3a893f6b8b6c10ff281fcdfe0b4a4ddafe89023 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 10 Jan 2021 17:30:12 +0100
Subject: Implement program change control for the midi, winmidi and jack
 backends (Fixes #79)

---
 backends/jack.c     |  9 ++++++---
 backends/jack.h     |  7 ++++---
 backends/jack.md    |  7 ++++++-
 backends/midi.c     | 18 +++++++++++++++++-
 backends/midi.md    |  4 +++-
 backends/winmidi.c  | 12 +++++++++---
 backends/winmidi.h  |  7 ++++---
 backends/winmidi.md |  4 +++-
 8 files changed, 52 insertions(+), 16 deletions(-)

diff --git a/backends/jack.c b/backends/jack.c
index 176144f..fe74a80 100644
--- a/backends/jack.c
+++ b/backends/jack.c
@@ -79,7 +79,7 @@ static int mmjack_midiqueue_append(mmjack_port* port, mmjack_channel_ident ident
 }
 
 static void mmjack_process_midiout(void* buffer, size_t sample_offset, uint8_t type, uint8_t channel, uint8_t control, uint16_t value){
-	jack_midi_data_t* event_data = jack_midi_event_reserve(buffer, sample_offset, (type == midi_aftertouch) ? 2 : 3);
+	jack_midi_data_t* event_data = jack_midi_event_reserve(buffer, sample_offset, (type == midi_aftertouch || type == midi_program) ? 2 : 3);
 
 	if(!event_data){
 		LOG("Failed to reserve MIDI stream data");
@@ -95,7 +95,7 @@ static void mmjack_process_midiout(void* buffer, size_t sample_offset, uint8_t t
 		event_data[1] = value & 0x7F;
 		event_data[2] = (value >> 7) & 0x7F;
 	}
-	else if(type == midi_aftertouch){
+	else if(type == midi_aftertouch || type == midi_program){
 		event_data[1] = value & 0x7F;
 		event_data[2] = 0;
 	}
@@ -192,7 +192,7 @@ static int mmjack_process_midi(instance* inst, mmjack_port* port, size_t nframes
 					ident.fields.sub_control = 0;
 					value = event.buffer[1] | (event.buffer[2] << 7);
 				}
-				else if(ident.fields.sub_type == midi_aftertouch){
+				else if(ident.fields.sub_type == midi_aftertouch || ident.fields.sub_type == midi_program){
 					ident.fields.sub_control = 0;
 					value = event.buffer[1];
 				}
@@ -501,6 +501,9 @@ static int mmjack_parse_midispec(mmjack_channel_ident* ident, char* spec){
 	else if(!strncmp(next_token, "aftertouch", 10)){
 		ident->fields.sub_type = midi_aftertouch;
 	}
+	else if(!strncmp(next_token, "program", 7)){
+		ident->fields.sub_type = midi_program;
+	}
 	else{
 		LOGPF("Unknown MIDI control type in spec %s", spec);
 		return 1;
diff --git a/backends/jack.h b/backends/jack.h
index 762282b..42905f1 100644
--- a/backends/jack.h
+++ b/backends/jack.h
@@ -24,12 +24,13 @@ static int mmjack_shutdown(size_t n, instance** inst);
 enum /*mmjack_midi_channel_type*/ {
 	midi_none = 0,
 	midi_note = 0x90,
-	midi_cc = 0xB0,
 	midi_pressure = 0xA0,
+	midi_cc = 0xB0,
+	midi_program = 0xC0,
 	midi_aftertouch = 0xD0,
 	midi_pitchbend = 0xE0,
-	midi_rpn = 0xF0,
-	midi_nrpn = 0xF1
+	midi_rpn = 0xF1,
+	midi_nrpn = 0xF2
 };
 
 typedef union {
diff --git a/backends/jack.md b/backends/jack.md
index 4ff77f6..c67f060 100644
--- a/backends/jack.md
+++ b/backends/jack.md
@@ -56,6 +56,9 @@ MIDI ports provide subchannels for the various MIDI controls available. Each MID
 corresponding pressure controls for each note, 128 control change (CC) controls (numbered likewise),
 one channel wide "aftertouch" control and one channel-wide pitchbend control.
 
+Every MIDI channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
+the CC controls 101/100/99/98/38/6. Both control types have 14-bit IDs and 14-bit values.
+
 A MIDI port subchannel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
 
@@ -66,16 +69,18 @@ The following values are recognized for `type`:
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `program` - Channel program change messages
 * `rpn` - Registered parameter numbers (14-bit extension)
 * `nrpn` - Non-registered parameter numbers (14-bit extension)
 
-The `pitch` and `aftertouch` events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
+The `pitch`, `aftertouch` and `program` messages/events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
 
 Example mappings:
 ```
 jack1.cv_in > jack1.midi_out.ch0.note3
 jack1.midi_in.ch0.pitch > jack1.cv_out
 jack2.midi_in.ch0.nrpn900 > jack1.midi_out.ch1.rpn1
+jack1.midi_in.ch15.note1 > jack1.midi_out.ch4.program
 ```
 
 The MIDI subchannel syntax is intentionally kept compatible to the different MIDI backends also supported
diff --git a/backends/midi.c b/backends/midi.c
index e32c975..10c8c4a 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -14,6 +14,7 @@ enum /*_midi_channel_type*/ {
 	pressure,
 	aftertouch,
 	pitchbend,
+	program,
 	rpn,
 	nrpn
 };
@@ -167,6 +168,9 @@ static channel* midi_channel(instance* inst, char* spec, uint8_t flags){
 	else if(!strncmp(channel, "pitch", 5)){
 		ident.fields.type = pitchbend;
 	}
+	else if(!strncmp(channel, "program", 7)){
+		ident.fields.type = program;
+	}
 	else if(!strncmp(channel, "aftertouch", 10)){
 		ident.fields.type = aftertouch;
 	}
@@ -208,6 +212,9 @@ static void midi_tx(int port, uint8_t type, uint8_t channel, uint8_t control, ui
 		case aftertouch:
 			snd_seq_ev_set_chanpress(&ev, channel, value);
 			break;
+		case program:
+			snd_seq_ev_set_pgmchange(&ev, channel, value);
+			break;
 	}
 
 	snd_seq_event_output(sequencer, &ev);
@@ -269,6 +276,8 @@ static char* midi_type_name(uint8_t type){
 			return "aftertouch";
 		case pitchbend:
 			return "pitch";
+		case program:
+			return "program";
 	}
 	return "unknown";
 }
@@ -399,6 +408,7 @@ static int midi_handle(size_t num, managed_fd* fds){
 			case SND_SEQ_EVENT_CHANPRESS:
 				ident.fields.type = aftertouch;
 				ident.fields.channel = ev->data.control.channel;
+				ident.fields.control = 0;
 				val.normalised = (double) ev->data.control.value / 127.0;
 				break;
 			case SND_SEQ_EVENT_PITCHBEND:
@@ -407,6 +417,12 @@ static int midi_handle(size_t num, managed_fd* fds){
 				ident.fields.channel = ev->data.control.channel;
 				val.normalised = ((double) ev->data.control.value + 8192) / 16383.0;
 				break;
+			case SND_SEQ_EVENT_PGMCHANGE:
+				ident.fields.type = program;
+				ident.fields.control = 0;
+				ident.fields.channel = ev->data.control.channel;
+				val.normalised = (double) ev->data.control.value / 127.0;
+				break;
 			case SND_SEQ_EVENT_CONTROLLER:
 				ident.fields.type = cc;
 				ident.fields.channel = ev->data.control.channel;
@@ -437,7 +453,7 @@ static int midi_handle(size_t num, managed_fd* fds){
 		}
 
 		if(midi_config.detect && event_type){
-			if(ident.fields.type == pitchbend || ident.fields.type == aftertouch){
+			if(ident.fields.type == pitchbend || ident.fields.type == aftertouch || ident.fields.type == program){
 				LOGPF("Incoming data on channel %s.ch%d.%s", inst->name, ident.fields.channel, event_type);
 			}
 			else{
diff --git a/backends/midi.md b/backends/midi.md
index 60a4d06..6280205 100644
--- a/backends/midi.md
+++ b/backends/midi.md
@@ -31,13 +31,14 @@ The MIDI backend supports mapping different MIDI events to MIDIMonster channels.
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `program` - Channel program change messages
 * `rpn` - Registered parameter numbers (14-bit extension)
 * `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
 
-The `pitch` and `aftertouch` events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
+The `pitch`, `aftertouch` and `program` messages/events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
 
 MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (numbered `0` through `127`), which
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
@@ -53,6 +54,7 @@ midi1.channel15.pressure1 > midi1.channel0.note0
 midi1.ch1.aftertouch > midi2.ch2.cc0
 midi1.ch0.pitch > midi2.ch1.pitch
 midi1.ch0.nrpn900 > midi2.ch0.rpn1
+midi2.ch15.note1 > midi1.ch2.program
 ```
 #### Known bugs / problems
 
diff --git a/backends/winmidi.c b/backends/winmidi.c
index ec0fb44..a1fa686 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -169,6 +169,9 @@ static channel* winmidi_channel(instance* inst, char* spec, uint8_t flags){
 	else if(!strncmp(next_token, "aftertouch", 10)){
 		ident.fields.type = aftertouch;
 	}
+	else if(!strncmp(next_token, "program", 7)){
+		ident.fields.type = program;
+	}
 	else{
 		LOGPF("Unknown control type in %s", spec);
 		return NULL;
@@ -203,7 +206,7 @@ static void winmidi_tx(HMIDIOUT port, uint8_t type, uint8_t channel, uint8_t con
 		output.components.data1 = value & 0x7F;
 		output.components.data2 = (value >> 7) & 0x7F;
 	}
-	else if(type == aftertouch){
+	else if(type == aftertouch || type == program){
 		output.components.data1 = value;
 		output.components.data2 = 0;
 	}
@@ -270,6 +273,8 @@ static char* winmidi_type_name(uint8_t typecode){
 			return "aftertouch";
 		case pitchbend:
 			return "pitch";
+		case program:
+			return "program";
 	}
 	return "unknown";
 }
@@ -294,7 +299,8 @@ static int winmidi_handle(size_t num, managed_fd* fds){
 		if(backend_config.detect){
 			//pretty-print channel-wide events
 			if(backend_config.event[u].channel.fields.type == pitchbend
-					|| backend_config.event[u].channel.fields.type == aftertouch){
+					|| backend_config.event[u].channel.fields.type == aftertouch
+					|| backend_config.event[u].channel.fields.type == program){
 				LOGPF("Incoming data on channel %s.ch%d.%s, value %f",
 						backend_config.event[u].inst->name,
 						backend_config.event[u].channel.fields.channel,
@@ -450,7 +456,7 @@ static void CALLBACK winmidi_input_callback(HMIDIIN device, unsigned message, DW
 				val.normalised = (double) ((input.components.data2 << 7) | input.components.data1) / 16383.0;
 				val.raw.u64 = input.components.data2 << 7 | input.components.data1;
 			}
-			else if(ident.fields.type == aftertouch){
+			else if(ident.fields.type == aftertouch || ident.fields.type == program){
 				ident.fields.control = 0;
 				val.normalised = (double) input.components.data1 / 127.0;
 				val.raw.u64 = input.components.data1;
diff --git a/backends/winmidi.h b/backends/winmidi.h
index 4d3e2dd..40b3554 100644
--- a/backends/winmidi.h
+++ b/backends/winmidi.h
@@ -31,12 +31,13 @@ typedef struct /*_winmidi_instance_data*/ {
 enum /*_winmidi_channel_type*/ {
 	none = 0,
 	note = 0x90,
-	cc = 0xB0,
 	pressure = 0xA0,
+	cc = 0xB0,
+	program = 0xC0,
 	aftertouch = 0xD0,
 	pitchbend = 0xE0,
-	rpn = 0xF0,
-	nrpn = 0xF1
+	rpn = 0xF1,
+	nrpn = 0xF2
 };
 
 typedef union {
diff --git a/backends/winmidi.md b/backends/winmidi.md
index 4de792a..9e7d9cc 100644
--- a/backends/winmidi.md
+++ b/backends/winmidi.md
@@ -33,13 +33,14 @@ The `winmidi` backend supports mapping different MIDI events as MIDIMonster chan
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `program` - Channel program change messages
 * `rpn` - Registered parameter numbers (14-bit extension)
 * `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
 
-The `pitch` and `aftertouch` events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
+The `pitch`, `aftertouch` and `program` messages/events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
 
 MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (numbered `0` through `127`), which
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
@@ -55,6 +56,7 @@ midi1.channel15.pressure1 > midi1.channel0.note0
 midi1.ch1.aftertouch > midi2.ch2.cc0
 midi1.ch0.pitch > midi2.ch1.pitch
 midi2.ch0.nrpn900 > midi1.ch1.rpn1
+midi2.ch15.note1 > midi1.ch2.program
 ```
 
 #### Known bugs / problems
-- 
cgit v1.2.3


From 8ff86335bc9f5233564a0f791174a9cc49ae2df4 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sun, 10 Jan 2021 19:10:01 +0100
Subject: Implement program change control for the rtpmidi backend (#79)

---
 backends/rtpmidi.c  | 23 +++++++++++++++--------
 backends/rtpmidi.h  |  3 ++-
 backends/rtpmidi.md |  4 +++-
 3 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/backends/rtpmidi.c b/backends/rtpmidi.c
index 7c5aa69..8d5525c 100644
--- a/backends/rtpmidi.c
+++ b/backends/rtpmidi.c
@@ -427,6 +427,8 @@ static char* rtpmidi_type_name(uint8_t type){
 			return "aftertouch";
 		case pitchbend:
 			return "pitch";
+		case program:
+			return "program";
 	}
 	return "unknown";
 }
@@ -552,7 +554,7 @@ static int rtpmidi_peer_applecommand(instance* inst, size_t peer, uint8_t contro
 
 	memcpy(&dest_addr, &(data->peer[peer].dest), min(sizeof(dest_addr), data->peer[peer].dest_len));
 	if(control){
-	//calculate remote control port from data port
+		//calculate remote control port from data port
 		((struct sockaddr_in*) &dest_addr)->sin_port = htobe16(be16toh(((struct sockaddr_in*) &dest_addr)->sin_port) - 1);
 	}
 
@@ -715,6 +717,9 @@ static channel* rtpmidi_channel(instance* inst, char* spec, uint8_t flags){
 	else if(!strncmp(next_token, "aftertouch", 10)){
 		ident.fields.type = aftertouch;
 	}
+	else if(!strncmp(next_token, "program", 7)){
+		ident.fields.type = program;
+	}
 	else{
 		LOGPF("Unknown control type in spec %s", spec);
 		return NULL;
@@ -761,11 +766,11 @@ static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 		payload[3] = v[u].normalised * 127.0;
 
 		if(ident.fields.type == pitchbend){
-			payload[2] = ((int)(v[u].normalised * 16384.0)) & 0x7F;
-			payload[3] = (((int)(v[u].normalised * 16384.0)) >> 7) & 0x7F;
+			payload[2] = ((int)(v[u].normalised * 16383.0)) & 0x7F;
+			payload[3] = (((int)(v[u].normalised * 16383.0)) >> 7) & 0x7F;
 		}
-		//channel-wide aftertouch is only 2 bytes
-		else if(ident.fields.type == aftertouch){
+		//channel-wides aftertouch and program are only 2 bytes
+		else if(ident.fields.type == aftertouch || ident.fields.type == program){
 			payload[2] = payload[3];
 			payload -= 1;
 			offset -= 1;
@@ -996,7 +1001,7 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 		ident.fields.channel = midi_status & 0x0F;
 
 		//single byte command
-		if(ident.fields.type == aftertouch){
+		if(ident.fields.type == aftertouch || ident.fields.type == program){
 			ident.fields.control = 0;
 			val.normalised = (double) frame[offset] / 127.0;
 			offset++;
@@ -1010,7 +1015,7 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 
 			if(ident.fields.type == pitchbend){
 				ident.fields.control = 0;
-				val.normalised = (double)((frame[offset] << 7) | frame[offset - 1]) / 16384.0;
+				val.normalised = (double)((frame[offset] << 7) | frame[offset - 1]) / 16383.0;
 			}
 			else{
 				ident.fields.control = frame[offset - 1];
@@ -1030,7 +1035,9 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 				ident.fields.type, ident.fields.channel, ident.fields.control, val.normalised);
 
 		if(cfg.detect){
-			if(ident.fields.type == pitchbend || ident.fields.type == aftertouch){
+			if(ident.fields.type == pitchbend
+					|| ident.fields.type == aftertouch
+					|| ident.fields.type == program){
 				LOGPF("Incoming data on channel %s.ch%d.%s, value %f",
 						inst->name, ident.fields.channel,
 						rtpmidi_type_name(ident.fields.type), val.normalised);
diff --git a/backends/rtpmidi.h b/backends/rtpmidi.h
index 7e6eccc..5f1621e 100644
--- a/backends/rtpmidi.h
+++ b/backends/rtpmidi.h
@@ -35,8 +35,9 @@ static int rtpmidi_shutdown(size_t n, instance** inst);
 enum /*_rtpmidi_channel_type*/ {
 	none = 0,
 	note = 0x90,
-	cc = 0xB0,
 	pressure = 0xA0,
+	cc = 0xB0,
+	program = 0xC0,
 	aftertouch = 0xD0,
 	pitchbend = 0xE0
 };
diff --git a/backends/rtpmidi.md b/backends/rtpmidi.md
index 82548bf..9f56f3d 100644
--- a/backends/rtpmidi.md
+++ b/backends/rtpmidi.md
@@ -63,11 +63,12 @@ The `rtpmidi` backend supports mapping different MIDI events to MIDIMonster chan
 * `pressure` - Note pressure/aftertouch messages
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
+* `program` - Channel program change messages
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
 
-The `pitch` and `aftertouch` events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
+The `pitch`, `aftertouch` program messages/events are channel-wide, thus they can be specified as `channel<channel>.<type>`.
 
 MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (numbered `0` through `127`), which
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
@@ -80,6 +81,7 @@ rmidi1.ch0.note9 > rmidi2.channel1.cc4
 rmidi1.channel15.pressure1 > rmidi1.channel0.note0
 rmidi1.ch1.aftertouch > rmidi2.ch2.cc0
 rmidi1.ch0.pitch > rmidi2.ch1.pitch
+rmidi2.ch15.note1 > rmidi2.ch2.program
 ```
 
 #### Known bugs / problems
-- 
cgit v1.2.3


From de1cbe2de1c558c21f1566cfa78b20daef828ed5 Mon Sep 17 00:00:00 2001
From: Paul Hedderly <paul+github@.mjr.org>
Date: Wed, 13 Jan 2021 08:17:36 +0000
Subject: prh: lua example to turn any value input to 1.0 to make pads boolean

---
 configs/returnone.lua | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 configs/returnone.lua

diff --git a/configs/returnone.lua b/configs/returnone.lua
new file mode 100644
index 0000000..cde0b03
--- /dev/null
+++ b/configs/returnone.lua
@@ -0,0 +1,24 @@
+-- ReturnOne by Paul Hedderly
+-- Sometimes you just want an on/off from linear pads
+-- For example I want to activate scenes in OBS from a Korg NanoPad2
+-- But I dont want to have to thump the pads to get a 1.0 output
+--
+-- You could use this as:
+--      [midi nanoP]
+--      read = nanoPAD2
+--      write = nanoPAD2
+--      [lua trackpad]
+--      script = trackpad.lua
+--      default-handler = returnone
+-- ..   
+-- 	nanoP.ch0.note{36..51} > returnone.one{1..16} -- To feed all the 16 pads to 
+--	returnone.outone1 > obs./obs/scene/1/preview
+--	returnone.outone2 > obs./obs/scene/2/preview
+-- etc
+-- The output channel will be the same as the channel you feed prepended "out"
+
+
+function returnone(v) -- Use a default function - then you can use any input channel name
+  if v>0 then output("out"..input_channel(),1) end;
+  if v==0 then output("out"..input_channel(),0) end;
+end
-- 
cgit v1.2.3


From d63b0d35fb22baa15c833dedbd54c971c62fee5b Mon Sep 17 00:00:00 2001
From: Paul Hedderly <paul+github@.mjr.org>
Date: Wed, 13 Jan 2021 08:18:01 +0000
Subject: prh: lua example to turn a trackpad into a numberpad and trigger
 swipes and gestures

---
 configs/trackpad.lua | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 configs/trackpad.lua

diff --git a/configs/trackpad.lua b/configs/trackpad.lua
new file mode 100644
index 0000000..0aa9de7
--- /dev/null
+++ b/configs/trackpad.lua
@@ -0,0 +1,59 @@
+-- Trackpad input by Paul Hedderly
+-- Expects three sources X, Y and touch
+-- On the Korg Nanopad2 these would be nanoP.ch0.cc1, nanoP.ch0.cc2, nanoP.ch0.cc16
+-- so you could map and feed this script with something like:
+--	[midi nanoP]
+--	read = nanoPAD2
+--	write = nanoPAD2
+--	[lua trackpad]
+--	script = trackpad.lua
+-- ..	
+--	nanoP.ch0.cc1 > trackpad.x
+-- 	nanoP.ch0.cc2 > trackpad.y
+-- 	nanoP.ch0.cc16 > trackpad.touch
+--
+-- Each touch will generate four outputs
+-- - on[1-9] - the first point of touch (might not be very useful!)
+-- - off[1-9] - the final point of touch
+-- - swipe[1-9][1-9] - the first and last as a *simple* gesture or swipe
+-- - gesture[1-9]..[1-9] - every segment you touch in order so you can do complicated gestures
+--
+-- Each output of 1 is followed by an output of 0
+-- You would map these as
+-- 	trackpad.on3 > ...
+-- 	trackpad.off9 > ....
+-- 	trackpad.swipe17 > .... -- would catch a line from top left to bottom left but could go anywhere in between
+-- 	trackpad.gesture78965 > .... would catch a backwards capital L starting at the bottom left
+
+-- -- Reserve state variables
+contact=0;
+trace="";
+x=0; y=0
+lpos=""
+
+function x(v) -- NOTE the code assumes that we get an X before the Y - Some devices might differ!
+	x=math.floor((v+0.09)*2.55)
+end
+
+function y(v)
+	y=2-math.floor((v+0.09)*2.55)	-- 2- so that we have 1 at the top
+	pos=""..x+1+y*3 			-- we need a string to compare
+	lpos=string.sub(trace,-1)
+	print("pos"..pos.." lpos"..lpos.." = "..trace)
+	if pos ~= lpos then trace=trace..pos end
+end
+
+function touch(v)
+	--  print("TOUCH .."..contact..".... trace"..trace)
+	if v==1 then contact=1
+	elseif v==0 then 
+		first=string.sub(trace,1,1); last=string.sub(trace,-1)
+		ends=first..last
+		output("on"..last,1); output ("on"..last,0)
+		output("off"..last,1); output ("off"..last,0)
+		output("swipe"..ends,1); output ("swipe"..ends,0)
+		output("gesture"..trace,1); output ("gesture"..trace,0)
+		print("TRACKPAD>>>"..trace.." ends.."..ends)
+		trace="" -- reset tracking
+	end;
+end
-- 
cgit v1.2.3


From 35f4798673194733358cd3db19a4d2baf70887fd Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 15 Jan 2021 21:35:21 +0100
Subject: Implement EPN's for the rtpmidi backend

---
 backends/midi.c     |   3 +-
 backends/rtpmidi.c  | 177 ++++++++++++++++++++++++++++++++++++++++++++++------
 backends/rtpmidi.h  |  20 ++++--
 backends/rtpmidi.md |  13 ++++
 backends/winmidi.c  |   2 +-
 5 files changed, 191 insertions(+), 24 deletions(-)

diff --git a/backends/midi.c b/backends/midi.c
index 10c8c4a..4bf846a 100644
--- a/backends/midi.c
+++ b/backends/midi.c
@@ -247,6 +247,7 @@ static int midi_set(instance* inst, size_t num, channel** c, channel_value* v){
 				}
 				break;
 			case pitchbend:
+				//TODO check whether this actually works that well
 				midi_tx(data->port, ident.fields.type, ident.fields.channel, ident.fields.control, (v[u].normalised * 16383.0) - 8192);
 				break;
 			default:
@@ -282,7 +283,7 @@ static char* midi_type_name(uint8_t type){
 	return "unknown";
 }
 
-//this state machine is used more-or-less verbatim in the winmidi and jack backends - fixes need to be applied there, too
+//this state machine is used more-or-less verbatim in the winmidi, rtpmidi and jack backends - fixes need to be applied there, too
 static void midi_handle_epn(instance* inst, uint8_t chan, uint16_t control, uint16_t value){
 	midi_instance_data* data = (midi_instance_data*) inst->impl;
 	midi_channel_ident ident = {
diff --git a/backends/rtpmidi.c b/backends/rtpmidi.c
index 8d5525c..3a54e26 100644
--- a/backends/rtpmidi.c
+++ b/backends/rtpmidi.c
@@ -429,6 +429,10 @@ static char* rtpmidi_type_name(uint8_t type){
 			return "pitch";
 		case program:
 			return "program";
+		case rpn:
+			return "rpn";
+		case nrpn:
+			return "nrpn";
 	}
 	return "unknown";
 }
@@ -579,6 +583,13 @@ static int rtpmidi_configure_instance(instance* inst, char* option, char* value)
 		LOGPF("Unknown instance mode %s for instance %s", value, inst->name);
 		return 1;
 	}
+	else if(!strcmp(option, "epn-tx")){
+		data->epn_tx_short = 0;
+		if(!strcmp(value, "short")){
+			data->epn_tx_short = 1;
+		}
+		return 0;
+	}
 	else if(!strcmp(option, "ssrc")){
 		data->ssrc = strtoul(value, NULL, 0);
 		if(!data->ssrc){
@@ -707,6 +718,14 @@ static channel* rtpmidi_channel(instance* inst, char* spec, uint8_t flags){
 		ident.fields.type = note;
 		next_token += 4;
 	}
+	else if(!strncmp(next_token, "rpn", 3)){
+		ident.fields.type = rpn;
+		next_token += 3;
+	}
+	else if(!strncmp(next_token, "nrpn", 4)){
+		ident.fields.type = nrpn;
+		next_token += 4;
+	}
 	else if(!strncmp(next_token, "pressure", 8)){
 		ident.fields.type = pressure;
 		next_token += 8;
@@ -733,6 +752,32 @@ static channel* rtpmidi_channel(instance* inst, char* spec, uint8_t flags){
 	return NULL;
 }
 
+static size_t rtpmidi_push_midi(uint8_t* payload, size_t bytes_left, uint8_t type, uint8_t channel, uint8_t control, uint16_t value){
+	//FIXME this is a bit simplistic but it works for now
+	if(bytes_left < 4){
+		return 0;
+	}
+
+	//encode timestamp
+	payload[0] = 0;
+
+	//encode midi command
+	payload[1] = type | channel;
+	payload[2] = control;
+	payload[3] = value & 0x7F;
+
+	if(type == pitchbend){
+		payload[2] = value & 0x7F;
+		payload[3] = (value >> 7) & 0x7F;
+	}
+	//channel-wides aftertouch and program are only 2 bytes
+	else if(type == aftertouch || type == program){
+		payload[2] = payload[3];
+		return 3;
+	}
+	return 4;
+}
+
 static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v){
 	rtpmidi_instance_data* data = (rtpmidi_instance_data*) inst->impl;
 	uint8_t frame[RTPMIDI_PACKET_BUFFER] = "";
@@ -741,6 +786,7 @@ static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 	size_t offset = sizeof(rtpmidi_header) + sizeof(rtpmidi_command_header), u = 0;
 	uint8_t* payload = frame + offset;
 	rtpmidi_channel_ident ident;
+	size_t command_length = 0;
 
 	rtp_header->vpxcc = RTPMIDI_HEADER_MAGIC;
 	//some receivers seem to have problems reading rfcs and interpreting the marker bit correctly
@@ -757,27 +803,37 @@ static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 	for(u = 0; u < num; u++){
 		ident.label = c[u]->ident;
 
-		//encode timestamp
-		payload[0] = 0;
-
-		//encode midi command
-		payload[1] = ident.fields.type | ident.fields.channel;
-		payload[2] = ident.fields.control;
-		payload[3] = v[u].normalised * 127.0;
-
-		if(ident.fields.type == pitchbend){
-			payload[2] = ((int)(v[u].normalised * 16383.0)) & 0x7F;
-			payload[3] = (((int)(v[u].normalised * 16383.0)) >> 7) & 0x7F;
+		switch(ident.fields.type){
+			case rpn:
+			case nrpn:
+				//transmit parameter number
+				command_length = rtpmidi_push_midi(payload + offset, sizeof(frame) - offset, cc, ident.fields.channel, (ident.fields.type == rpn) ? 101 : 99, (ident.fields.control >> 7) & 0x7F);
+				command_length += rtpmidi_push_midi(payload + offset + command_length, sizeof(frame) - offset, cc, ident.fields.channel, (ident.fields.type == rpn) ? 100 : 98, ident.fields.control & 0x7F);
+
+				//transmit parameter value
+				command_length += rtpmidi_push_midi(payload + offset + command_length, sizeof(frame) - offset, cc, ident.fields.channel, 6, (((uint16_t) (v[u].normalised * 16383.0)) >> 7) & 0x7F);
+				command_length += rtpmidi_push_midi(payload + offset + command_length, sizeof(frame) - offset, cc, ident.fields.channel, 38, ((uint16_t) (v[u].normalised * 16383.0)) & 0x7F);
+
+				if(!data->epn_tx_short){
+					//clear active parameter
+					command_length += rtpmidi_push_midi(payload + offset + command_length, sizeof(frame) - offset, cc, ident.fields.channel, 101, 127);
+					command_length += rtpmidi_push_midi(payload + offset + command_length, sizeof(frame) - offset, cc, ident.fields.channel, 100, 127);
+				}
+				break;
+			case pitchbend:
+				//TODO check whether this works
+				command_length = rtpmidi_push_midi(payload + offset, sizeof(frame) - offset, ident.fields.type, ident.fields.channel, ident.fields.control, v[u].normalised * 16383.0);
+				break;
+			default:
+				command_length = rtpmidi_push_midi(payload + offset, sizeof(frame) - offset, ident.fields.type, ident.fields.channel, ident.fields.control, v[u].normalised * 127.0);
 		}
-		//channel-wides aftertouch and program are only 2 bytes
-		else if(ident.fields.type == aftertouch || ident.fields.type == program){
-			payload[2] = payload[3];
-			payload -= 1;
-			offset -= 1;
+
+		if(command_length == 0){
+			LOGPF("Transmit buffer size exceeded on %s", inst->name);
+			break;
 		}
 
-		payload += 4;
-		offset += 4;
+		offset += command_length;
 	}
 
 	//update command section length
@@ -929,6 +985,79 @@ static int rtpmidi_handle_applemidi(instance* inst, int fd, uint8_t* frame, size
 	return 0;
 }
 
+//this state machine was copied more-or-less verbatim from the alsa midi implementation - fixes there will need to be integrated
+static void rtpmidi_handle_epn(instance* inst, uint8_t chan, uint16_t control, uint16_t value){
+	rtpmidi_instance_data* data = (rtpmidi_instance_data*) inst->impl;
+	rtpmidi_channel_ident ident = {
+		.label = 0
+	};
+	channel* changed = NULL;
+	channel_value val;
+
+	//switching between nrpn and rpn clears all valid bits
+	if(((data->epn_status[chan] & EPN_NRPN) && (control == 101 || control == 100))
+				|| (!(data->epn_status[chan] & EPN_NRPN) && (control == 99 || control == 98))){
+		data->epn_status[chan] &= ~(EPN_NRPN | EPN_PARAMETER_LO | EPN_PARAMETER_HI);
+	}
+
+	//setting an address always invalidates the value valid bits
+	if(control >= 98 && control <= 101){
+		data->epn_status[chan] &= ~EPN_VALUE_HI;
+	}
+
+	//parameter hi
+	if(control == 101 || control == 99){
+		data->epn_control[chan] &= 0x7F;
+		data->epn_control[chan] |= value << 7;
+		data->epn_status[chan] |= EPN_PARAMETER_HI | ((control == 99) ? EPN_NRPN : 0);
+		if(control == 101 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_HI;
+		}
+	}
+
+	//parameter lo
+	if(control == 100 || control == 98){
+		data->epn_control[chan] &= ~0x7F;
+		data->epn_control[chan] |= value & 0x7F;
+		data->epn_status[chan] |= EPN_PARAMETER_LO | ((control == 98) ? EPN_NRPN : 0);
+		if(control == 100 && value == 127){
+			data->epn_status[chan] &= ~EPN_PARAMETER_LO;
+		}
+	}
+
+	//value hi, clears low, mark as update candidate
+	if(control == 6
+			//check if parameter is set before accepting value update
+			&& ((data->epn_status[chan] & (EPN_PARAMETER_HI | EPN_PARAMETER_LO)) == (EPN_PARAMETER_HI | EPN_PARAMETER_LO))){
+		data->epn_value[chan] = value << 7;
+		data->epn_status[chan] |= EPN_VALUE_HI;
+	}
+
+	//value lo, flush the value
+	if(control == 38
+			&& data->epn_status[chan] & EPN_VALUE_HI){
+		data->epn_value[chan] &= ~0x7F;
+		data->epn_value[chan] |= value & 0x7F;
+		data->epn_status[chan] &= ~EPN_VALUE_HI;
+
+		if(cfg.detect){
+			LOGPF("Incoming EPN data on channel %s.ch%d.%s%d", inst->name, chan, data->epn_status[chan] & EPN_NRPN ? "nrpn" : "rpn", data->epn_control[chan]);
+		}
+
+		//find the updated channel
+		ident.fields.type = data->epn_status[chan] & EPN_NRPN ? nrpn : rpn;
+		ident.fields.channel = chan;
+		ident.fields.control = data->epn_control[chan];
+		val.normalised = (double) data->epn_value[chan] / 16383.0;
+
+		//push the new value
+		changed = mm_channel(inst, ident.label, 0);
+		if(changed){
+			mm_channel_event(changed, val);
+		}
+	}
+}
+
 static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 	uint16_t length = 0;
 	size_t offset = 1, decode_time = 0, command_bytes = 0;
@@ -1004,6 +1133,7 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 		if(ident.fields.type == aftertouch || ident.fields.type == program){
 			ident.fields.control = 0;
 			val.normalised = (double) frame[offset] / 127.0;
+			val.raw.u64 = frame[offset];
 			offset++;
 		}
 		//two-byte command
@@ -1016,16 +1146,19 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 			if(ident.fields.type == pitchbend){
 				ident.fields.control = 0;
 				val.normalised = (double)((frame[offset] << 7) | frame[offset - 1]) / 16383.0;
+				val.raw.u64 = (frame[offset] << 7) | frame[offset - 1];
 			}
 			else{
 				ident.fields.control = frame[offset - 1];
 				val.normalised = (double) frame[offset] / 127.0;
+				val.raw.u64 = frame[offset];
 			}
 
 			//fix-up note off events
 			if(ident.fields.type == 0x80){
 				ident.fields.type = note;
 				val.normalised = 0;
+				val.raw.u64 = 0;
 			}
 
 			offset++;
@@ -1034,6 +1167,14 @@ static int rtpmidi_parse(instance* inst, uint8_t* frame, size_t bytes){
 		DBGPF("Decoded command type %02X channel %d control %d value %f",
 				ident.fields.type, ident.fields.channel, ident.fields.control, val.normalised);
 
+		//forward EPN CCs to the EPN state machine
+		if(ident.fields.type == cc
+				&& ((ident.fields.control <= 101 && ident.fields.control >= 98)
+					|| ident.fields.control == 6
+					|| ident.fields.control == 38)){
+			rtpmidi_handle_epn(inst, ident.fields.channel, ident.fields.control, val.raw.u64);
+		}	
+
 		if(cfg.detect){
 			if(ident.fields.type == pitchbend
 					|| ident.fields.type == aftertouch
diff --git a/backends/rtpmidi.h b/backends/rtpmidi.h
index 5f1621e..e88530f 100644
--- a/backends/rtpmidi.h
+++ b/backends/rtpmidi.h
@@ -32,6 +32,11 @@ static int rtpmidi_shutdown(size_t n, instance** inst);
 #define DNS_OPCODE(a) (((a) & 0x78) >> 3)
 #define DNS_RESPONSE(a) ((a) & 0x80)
 
+#define EPN_NRPN 8
+#define EPN_PARAMETER_HI 4
+#define EPN_PARAMETER_LO 2
+#define EPN_VALUE_HI 1
+
 enum /*_rtpmidi_channel_type*/ {
 	none = 0,
 	note = 0x90,
@@ -39,7 +44,9 @@ enum /*_rtpmidi_channel_type*/ {
 	cc = 0xB0,
 	program = 0xC0,
 	aftertouch = 0xD0,
-	pitchbend = 0xE0
+	pitchbend = 0xE0,
+	rpn = 0xF1,
+	nrpn = 0xF2
 };
 
 typedef enum /*_rtpmidi_instance_mode*/ {
@@ -50,10 +57,10 @@ typedef enum /*_rtpmidi_instance_mode*/ {
 
 typedef union {
 	struct {
-		uint8_t pad[5];
+		uint8_t pad[4];
 		uint8_t type;
 		uint8_t channel;
-		uint8_t control;
+		uint16_t control;
 	} fields;
 	uint64_t label;
 } rtpmidi_channel_ident;
@@ -68,7 +75,7 @@ typedef struct /*_rtpmidi_peer*/ {
 	ssize_t invite; //invite-list index for apple-mode learned peers (used to track ipv6/ipv4 overlapping invitations)
 } rtpmidi_peer;
 
-typedef struct /*_rtmidi_instance_data*/ {
+typedef struct /*_rtpmidi_instance_data*/ {
 	rtpmidi_instance_mode mode;
 
 	int fd;
@@ -80,6 +87,11 @@ typedef struct /*_rtmidi_instance_data*/ {
 	uint32_t ssrc;
 	uint16_t sequence;
 
+	uint8_t epn_tx_short;
+	uint16_t epn_control[16];
+	uint16_t epn_value[16];
+	uint8_t epn_status[16];
+
 	//apple-midi config
 	char* accept;
 	uint64_t last_announce;
diff --git a/backends/rtpmidi.md b/backends/rtpmidi.md
index 9f56f3d..8014572 100644
--- a/backends/rtpmidi.md
+++ b/backends/rtpmidi.md
@@ -38,6 +38,7 @@ Common instance configuration parameters
 | `ssrc`	| `0xDEADBEEF`		| Randomly generated	| 32-bit synchronization source identifier |
 | `mode`	| `direct`		| none			| Instance session management mode (`direct` or `apple`) |
 | `peer`	| `10.1.2.3 9001`	| none			| MIDI session peer, may be specified multiple times. Bypasses session discovery (but still performs session negotiation) |
+| `epn-tx`	| `short`		| `full`		| Configure whether to clear the active parameter number after transmitting an `nrpn` or `rpn` parameter. |
 
 `direct` mode instance configuration parameters
 
@@ -64,6 +65,8 @@ The `rtpmidi` backend supports mapping different MIDI events to MIDIMonster chan
 * `aftertouch` - Channel-wide aftertouch messages
 * `pitch` - Channel pitchbend messages
 * `program` - Channel program change messages
+* `rpn` - Registered parameter numbers (14-bit extension)
+* `nrpn` - Non-registered parameter numbers (14-bit extension)
 
 A MIDIMonster channel is specified using the syntax `channel<channel>.<type><index>`. The shorthand `ch` may be
 used instead of the word `channel` (Note that `channel` here refers to the MIDI channel number).
@@ -74,6 +77,9 @@ MIDI channels range from `0` to `15`. Each MIDI channel consists of 128 notes (n
 additionally each have a pressure control, 128 CC's (numbered likewise), a channel pressure control (also called
 'channel aftertouch') and a pitch control which may all be mapped to individual MIDIMonster channels.
 
+Every MIDI channel also provides `rpn` and `nrpn` controls, which are implemented on top of the MIDI protocol, using
+the CC controls 101/100/99/98/38/6. Both control types have 14-bit IDs and 14-bit values.
+
 Example mappings:
 
 ```
@@ -82,6 +88,7 @@ rmidi1.channel15.pressure1 > rmidi1.channel0.note0
 rmidi1.ch1.aftertouch > rmidi2.ch2.cc0
 rmidi1.ch0.pitch > rmidi2.ch1.pitch
 rmidi2.ch15.note1 > rmidi2.ch2.program
+rmidi2.ch0.nrpn900 > rmidi1.ch1.rpn1
 ```
 
 #### Known bugs / problems
@@ -93,6 +100,12 @@ The mDNS and DNS-SD implementations in this backend are extremely terse, to the
 specifications in multiple cases. Due to the complexity involved in supporting these protocols, problems
 arising from this will be considered a bug only in cases where they hinder normal operation of the backend.
 
+Extended parameter numbers (EPNs, the `rpn` and `nrpn` control types) will also generate events on the controls (CC 101 through
+98, 38 and 6) that are used as the lower layer transport. When using EPNs, mapping those controls is probably not useful.
+
+EPN control types support only the full 14-bit transfer encoding, not the shorter variant transmitting only the 7
+high-order bits. This may be changed if there is sufficient interest in the functionality.
+
 mDNS discovery may announce flawed records when run on a host with multiple active interfaces.
 
 While this backend should be reasonably stable, there may be problematic edge cases simply due to the
diff --git a/backends/winmidi.c b/backends/winmidi.c
index a1fa686..649af2e 100644
--- a/backends/winmidi.c
+++ b/backends/winmidi.c
@@ -200,7 +200,7 @@ static void winmidi_tx(HMIDIOUT port, uint8_t type, uint8_t channel, uint8_t con
 
 	output.components.status = type | channel;
 	output.components.data1 = control;
-	output.components.data2 = value;
+	output.components.data2 = value & 0x7F;
 
 	if(type == pitchbend){
 		output.components.data1 = value & 0x7F;
-- 
cgit v1.2.3


From 71d86ec46259ce1b5488989ec30152c7cf810a8e Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Fri, 15 Jan 2021 23:49:12 +0100
Subject: Fix static analysis failures

---
 backends/rtpmidi.c | 7 ++++---
 backends/visca.h   | 3 ++-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/backends/rtpmidi.c b/backends/rtpmidi.c
index 3a54e26..f0987f2 100644
--- a/backends/rtpmidi.c
+++ b/backends/rtpmidi.c
@@ -783,10 +783,9 @@ static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 	uint8_t frame[RTPMIDI_PACKET_BUFFER] = "";
 	rtpmidi_header* rtp_header = (rtpmidi_header*) frame;
 	rtpmidi_command_header* command_header = (rtpmidi_command_header*) (frame + sizeof(rtpmidi_header));
-	size_t offset = sizeof(rtpmidi_header) + sizeof(rtpmidi_command_header), u = 0;
+	size_t command_length = 0, offset = sizeof(rtpmidi_header) + sizeof(rtpmidi_command_header), u = 0;
 	uint8_t* payload = frame + offset;
 	rtpmidi_channel_ident ident;
-	size_t command_length = 0;
 
 	rtp_header->vpxcc = RTPMIDI_HEADER_MAGIC;
 	//some receivers seem to have problems reading rfcs and interpreting the marker bit correctly
@@ -845,7 +844,9 @@ static int rtpmidi_set(instance* inst, size_t num, channel** c, channel_value* v
 
 	for(u = 0; u < data->peers; u++){
 		if(data->peer[u].active && data->peer[u].connected){
-			sendto(data->fd, frame, offset, 0, (struct sockaddr*) &data->peer[u].dest, data->peer[u].dest_len);
+			if(sendto(data->fd, frame, offset, 0, (struct sockaddr*) &data->peer[u].dest, data->peer[u].dest_len) <= 0){
+				LOGPF("Failed to transmit to peer: %s", mmbackend_socket_strerror(errno));
+			}
 		}
 	}
 
diff --git a/backends/visca.h b/backends/visca.h
index 47ada19..1004076 100644
--- a/backends/visca.h
+++ b/backends/visca.h
@@ -88,5 +88,6 @@ static struct {
 	[store] = {"store", 7, {0x80, 0x01, 0x04, 0x3F, 0x01, 0, 0xFF}, 0, 254, 0, ptz_set_memory_store},
 	[home] = {"home", 5, {0x80, 0x01, 0x06, 0x04, 0xFF}, 0, 0, 0, NULL},
 	[relmove] = {"move", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0, 0, 0xFF}, 0, 1, 0, ptz_set_relmove},
-	[stop] = {"stop", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0x03, 0x03, 0xFF}, 0, 0, 0, ptz_set_relmove}
+	[stop] = {"stop", 9, {0x80, 0x01, 0x06, 0x01, 0, 0, 0x03, 0x03, 0xFF}, 0, 0, 0, ptz_set_relmove},
+	[sentinel] = {"SENTINEL"}
 };
-- 
cgit v1.2.3


From b199f019b47829f3745e8af8e62ed1ac4e65acf9 Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 16 Jan 2021 11:43:10 +0100
Subject: Exit when losing evdev connection

---
 backends/evdev.c  | 9 ++++++++-
 backends/evdev.md | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/backends/evdev.c b/backends/evdev.c
index 4c734f9..3dbf837 100644
--- a/backends/evdev.c
+++ b/backends/evdev.c
@@ -367,7 +367,9 @@ static int evdev_handle(size_t num, managed_fd* fds){
 
 		data = (evdev_instance_data*) inst->impl;
 
-		for(read_status = libevdev_next_event(data->input_ev, read_flags, &ev); read_status >= 0; read_status = libevdev_next_event(data->input_ev, read_flags, &ev)){
+		for(read_status = libevdev_next_event(data->input_ev, read_flags, &ev);
+				read_status == LIBEVDEV_READ_STATUS_SUCCESS || read_status == LIBEVDEV_READ_STATUS_SYNC;
+				read_status = libevdev_next_event(data->input_ev, read_flags, &ev)){
 			read_flags = LIBEVDEV_READ_FLAG_NORMAL;
 			if(read_status == LIBEVDEV_READ_STATUS_SYNC){
 				read_flags = LIBEVDEV_READ_FLAG_SYNC;
@@ -383,6 +385,11 @@ static int evdev_handle(size_t num, managed_fd* fds){
 				return 1;
 			}
 		}
+
+		if(read_status != -EAGAIN){
+			LOGPF("Failed to handle events: %s\n", strerror(-read_status));
+			return 1;
+		}
 	}
 
 	return 0;
diff --git a/backends/evdev.md b/backends/evdev.md
index d57201d..bf192b0 100644
--- a/backends/evdev.md
+++ b/backends/evdev.md
@@ -16,7 +16,7 @@ This functionality may require elevated privileges (such as special group member
 | Option	| Example value		| Default value | Description						|
 |---------------|-----------------------|---------------|-------------------------------------------------------|
 | `device`	| `/dev/input/event1`	| none		| `evdev` device to use as input device			|
-| `input`	| `Xbox Wireless`	| none		| Presentation name of evdev device to use as input (prefix-matched) |
+| `input`	| `Xbox Wireless`	| none		| Presentation name of evdev device to use as input (prefix-matched), can be used instead of the `device` option |
 | `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 |
-- 
cgit v1.2.3


From 91764dfc3ad86994ce27e5c80a92c034e12b849c Mon Sep 17 00:00:00 2001
From: cbdev <cb@cbcdn.com>
Date: Sat, 16 Jan 2021 19:34:21 +0100
Subject: Add notes

---
 TODO | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/TODO b/TODO
index 2ab5f10..9158e24 100644
--- a/TODO
+++ b/TODO
@@ -10,3 +10,6 @@ move all typenames to _t
 per-channel filters
 	* invert
 	* edge detection
+
+channel discovery / enumeration
+note exit condition/reconnection details for backends
-- 
cgit v1.2.3