6 files changed, 224 insertions, 211 deletions

diff --git a/drumgizmo/input/inputdummy.cc b/drumgizmo/input/inputdummy.cc
index f078cd5..f2d33b7 100644
--- a/drumgizmo/input/inputdummy.cc
+++ b/drumgizmo/input/inputdummy.cc
@@ -26,33 +26,24 @@
  */
 #include "inputdummy.h"
 
-DummyInputEngine::DummyInputEngine() {
-}
+DummyInputEngine::DummyInputEngine() {}
 
-DummyInputEngine::~DummyInputEngine() {
-}
+DummyInputEngine::~DummyInputEngine() {}
 
-bool DummyInputEngine::init(Instruments& instruments) {
-	return true;
-}
+bool DummyInputEngine::init(Instruments &instruments) { return true; }
 
-void DummyInputEngine::setParm(std::string parm, std::string value) {
-}
+void DummyInputEngine::setParm(std::string parm, std::string value) {}
 
-bool DummyInputEngine::start() {
-	return true;
-}
+bool DummyInputEngine::start() { return true; }
 
-void DummyInputEngine::stop() {
-}
+void DummyInputEngine::stop() {}
 
-void DummyInputEngine::pre() {
-}
+void DummyInputEngine::pre() {}
 
-event_t* DummyInputEngine::run(size_t pos, size_t len, size_t *nevents) {
+event_t *DummyInputEngine::run(size_t pos, size_t len, size_t *nevents)
+{
 	nevents = 0u;
 	return nullptr;
 }
 
-void DummyInputEngine::post() {
-}
+void DummyInputEngine::post() {}
diff --git a/drumgizmo/input/inputdummy.h b/drumgizmo/input/inputdummy.h
index b047ba7..fb84443 100644
--- a/drumgizmo/input/inputdummy.h
+++ b/drumgizmo/input/inputdummy.h
@@ -27,18 +27,18 @@
 #pragma once
 #include <audioinputengine.h>
 
-class DummyInputEngine
-	: public AudioInputEngine {
-	public:
-		DummyInputEngine();
-		~DummyInputEngine();
-		
-		// based on AudioInputEngine
-		bool init(Instruments &instruments) override;
-		void setParm(std::string parm, std::string value) override;
-		bool start() override;
-		void stop() override;
-		void pre() override;
-		event_t* run(size_t pos, size_t len, size_t* nevents) override;
-		void post() override;
+class DummyInputEngine : public AudioInputEngine
+{
+public:
+	DummyInputEngine();
+	~DummyInputEngine();
+
+	// based on AudioInputEngine
+	bool init(Instruments &instruments) override;
+	void setParm(std::string parm, std::string value) override;
+	bool start() override;
+	void stop() override;
+	void pre() override;
+	event_t *run(size_t pos, size_t len, size_t *nevents) override;
+	void post() override;
 };
diff --git a/drumgizmo/input/jackmidi.cc b/drumgizmo/input/jackmidi.cc
index ba4e8b3..5ae6add 100644
--- a/drumgizmo/input/jackmidi.cc
+++ b/drumgizmo/input/jackmidi.cc
@@ -32,101 +32,103 @@
 
 int const NOTE_ON = 0x90;
 
-JackMidiInputEngine::JackMidiInputEngine(JackClient& client)
-	: AudioInputEngine{}
-	, JackProcess{}
-	, client(client)
-	, port{nullptr}
-	, midimap{}
-	, midi_mapper{}
-	, pos{0u}
-	, list{nullptr}
-	, listsize{0u} {
+JackMidiInputEngine::JackMidiInputEngine(JackClient &client)
+    : AudioInputEngine{}, JackProcess{}, client(client), port{nullptr},
+      midimap{}, midi_mapper{}, pos{0u}, list{nullptr}, listsize{0u}
+{
 	client.add(*this);
 }
 
-JackMidiInputEngine::~JackMidiInputEngine() {
-	client.remove(*this);
-}
+JackMidiInputEngine::~JackMidiInputEngine() { client.remove(*this); }
 
-bool JackMidiInputEngine::isMidiEngine() {
-	return true;
-}
+bool JackMidiInputEngine::isMidiEngine() { return true; }
 
-bool JackMidiInputEngine::init(Instruments& instruments) {
-	if (midimap == "") {
+bool JackMidiInputEngine::init(Instruments &instruments)
+{
+	if (midimap == "")
+	{
 		std::cerr << "[JackMidiInputEngine] Missing midimap filename\n";
 		return false;
 	}
 	MidiMapParser p{midimap};
-	if (p.parse()) {
-		std::cerr << "[JackmidiInputEngine] Failed to parse midimap '"
-			<< midimap << "'\n";
+	if (p.parse())
+	{
+		std::cerr << "[JackmidiInputEngine] Failed to parse midimap '" << midimap
+		          << "'\n";
 		return false;
 	}
 	midi_mapper.midimap = p.midimap;
-	for (auto i = 0u; i < instruments.size(); ++i) {
+	for (auto i = 0u; i < instruments.size(); ++i)
+	{
 		auto name = instruments[i]->name();
 		midi_mapper.instrmap[name] = i;
 	}
 	port = std::make_unique<JackPort>(client, "drumgizmo_midiin",
-		JACK_DEFAULT_MIDI_TYPE, JackPortIsInput);
+	                                  JACK_DEFAULT_MIDI_TYPE, JackPortIsInput);
 	return true;
 }
 
-void JackMidiInputEngine::setParm(std::string parm, std::string value) {
-	if (parm == "midimap") {
+void JackMidiInputEngine::setParm(std::string parm, std::string value)
+{
+	if (parm == "midimap")
+	{
 		// apply midimap filename
 		midimap = value;
-		
-	} else {
-		std::cerr << "[JackMidiInputEngine] Unsupported parameter '"
-			<< parm << "'\n";
+	}
+	else
+	{
+		std::cerr << "[JackMidiInputEngine] Unsupported parameter '" << parm
+		          << "'\n";
 	}
 }
 
-bool JackMidiInputEngine::start() {
+bool JackMidiInputEngine::start()
+{
 	client.activate();
 	return true;
 }
 
-void JackMidiInputEngine::stop() {
-}
+void JackMidiInputEngine::stop() {}
 
-void JackMidiInputEngine::pre() {
-}
+void JackMidiInputEngine::pre() {}
 
-event_t* JackMidiInputEngine::run(size_t pos, size_t len, size_t* nevents) {
+event_t *JackMidiInputEngine::run(size_t pos, size_t len, size_t *nevents)
+{
 	*nevents = listsize;
-	event_t* l = list;
-	printf("Owning raw pointer at drumgizmo/input/jackmidiinput.cc - GET RID OF THEM!\n");
+	event_t *l = list;
+	printf("Owning raw pointer at drumgizmo/input/jackmidi.cc - GET RID OF "
+	       "THEM!\n");
 	list = (event_t *)malloc(sizeof(event_t) * 1000);
 	listsize = 0;
 	return l;
 }
 
-void JackMidiInputEngine::post() {
-}
+void JackMidiInputEngine::post() {}
 
-void JackMidiInputEngine::process(jack_nframes_t num_frames) {
+void JackMidiInputEngine::process(jack_nframes_t num_frames)
+{
 	assert(port != nullptr);
-	void* buffer = jack_port_get_buffer(port->port, num_frames);
+	void *buffer = jack_port_get_buffer(port->port, num_frames);
 	jack_nframes_t num_events = jack_midi_get_event_count(buffer);
 
-	for(jack_nframes_t i = 0; i < num_events; ++i) {
+	for (jack_nframes_t i = 0; i < num_events; ++i)
+	{
 		jack_midi_event_t event;
 		jack_midi_event_get(&event, buffer, i);
-		if(event.size != 3) {
+		if (event.size != 3)
+		{
 			continue;
 		}
-		if((event.buffer[0] & NOTE_ON) != NOTE_ON) {
+		if ((event.buffer[0] & NOTE_ON) != NOTE_ON)
+		{
 			continue;
 		}
 		int key = event.buffer[1];
 		int velocity = event.buffer[2];
 		printf("Event key:%d vel:%d\n", key, velocity);
 		int k = midi_mapper.lookup(key);
-		if(k != -1 && velocity) {
+		if (k != -1 && velocity)
+		{
 			list[listsize].type = TYPE_ONSET;
 			list[listsize].instrument = k;
 			list[listsize].velocity = velocity / 127.0;
@@ -139,8 +141,7 @@ void JackMidiInputEngine::process(jack_nframes_t num_frames) {
 }
 
 /*
-		DrumKit* kit;
-		size_t pos;
-		EventQueue *eventqueue;
+    DrumKit* kit;
+    size_t pos;
+    EventQueue *eventqueue;
 */
-
diff --git a/drumgizmo/input/jackmidi.h b/drumgizmo/input/jackmidi.h
index 3c64f2d..41a3e55 100644
--- a/drumgizmo/input/jackmidi.h
+++ b/drumgizmo/input/jackmidi.h
@@ -34,34 +34,33 @@
 #include "midimapparser.h"
 #include "../jackclient.h"
 
-class JackMidiInputEngine
-	: public AudioInputEngine
-	, public JackProcess {
-	public:
-		JackMidiInputEngine(JackClient& client);
-		~JackMidiInputEngine();
-		
-		// based on AudioInputEngine
-		bool isMidiEngine() override;
-		bool init(Instruments& instruments) override;
-		void setParm(std::string parm, std::string value) override;
-		bool start() override;
-		void stop() override;
-		void pre() override;
-		event_t* run(size_t pos, size_t len, size_t* nevents) override;
-		void post() override;
-		
-		// based on JackProcess
-		void process(jack_nframes_t num_frames) override;
-		
-	private:
-		JackClient& client;
-		std::unique_ptr<JackPort> port;
-		
-		std::string midimap;
-		MidiMapper midi_mapper;
-		std::size_t pos;
-		
-		event_t* list;
-		size_t listsize;
+class JackMidiInputEngine : public AudioInputEngine, public JackProcess
+{
+public:
+	JackMidiInputEngine(JackClient &client);
+	~JackMidiInputEngine();
+
+	// based on AudioInputEngine
+	bool isMidiEngine() override;
+	bool init(Instruments &instruments) override;
+	void setParm(std::string parm, std::string value) override;
+	bool start() override;
+	void stop() override;
+	void pre() override;
+	event_t *run(size_t pos, size_t len, size_t *nevents) override;
+	void post() override;
+
+	// based on JackProcess
+	void process(jack_nframes_t num_frames) override;
+
+private:
+	JackClient &client;
+	std::unique_ptr<JackPort> port;
+
+	std::string midimap;
+	MidiMapper midi_mapper;
+	std::size_t pos;
+
+	event_t *list;
+	size_t listsize;
 };
diff --git a/drumgizmo/input/midifile.cc b/drumgizmo/input/midifile.cc
index c9aeaf8..0cc9dea 100644
--- a/drumgizmo/input/midifile.cc
+++ b/drumgizmo/input/midifile.cc
@@ -31,116 +31,131 @@
 int const NOTE_ON = 0x90;
 
 MidifileInputEngine::MidifileInputEngine()
-	: smf{nullptr}
-	, current_event{nullptr}
-	, file{}
-	, midimap{}
-	, speed{1.f}
-	, track{-1} // all tracks
-	, loop{false}
-	, offset{0.0} {
+    : smf{nullptr}, current_event{nullptr}, file{}, midimap{}, speed{1.f},
+      track{-1} // all tracks
+      ,
+      loop{false}, offset{0.0}
+{
 }
 
-MidifileInputEngine::~MidifileInputEngine() {
-	if (smf != nullptr) {
+MidifileInputEngine::~MidifileInputEngine()
+{
+	if (smf != nullptr)
+	{
 		smf_delete(smf);
 	}
 }
 
-bool MidifileInputEngine::isMidiEngine() {
-	return true;
-}
+bool MidifileInputEngine::isMidiEngine() { return true; }
 
-bool MidifileInputEngine::init(Instruments& instruments) {
-	if (file == "") {
+bool MidifileInputEngine::init(Instruments &instruments)
+{
+	if (file == "")
+	{
 		std::cerr << "[MidifileInputEngine] Missing midi filename\n";
 		return false;
 	}
-	if (midimap == "") {
+	if (midimap == "")
+	{
 		std::cerr << "[MidifileInputEngine] Missing midimap filename\n";
 		return false;
 	}
 	smf = smf_load(file.c_str());
-	if (smf == nullptr) {
-		std::cerr << "[MidifileInputEngine] Failed to load midifile '"
-			<< file << "'\n";
+	if (smf == nullptr)
+	{
+		std::cerr << "[MidifileInputEngine] Failed to load midifile '" << file
+		          << "'\n";
 		return false;
 	}
 	MidiMapParser p{midimap};
-	if (p.parse()) {
-		std::cerr << "[MidifileInputEngine] Failed to parse midimap '"
-			<< midimap << "'\n";
+	if (p.parse())
+	{
+		std::cerr << "[MidifileInputEngine] Failed to parse midimap '" << midimap
+		          << "'\n";
 		return false;
 	}
 	midi_mapper.midimap = p.midimap;
-	for (auto i = 0u; i < instruments.size(); ++i) {
+	for (auto i = 0u; i < instruments.size(); ++i)
+	{
 		auto name = instruments[i]->name();
 		midi_mapper.instrmap[name] = i;
 	}
 	return true;
 }
 
-void MidifileInputEngine::setParm(std::string parm, std::string value) {
-	if(parm == "file") {
+void MidifileInputEngine::setParm(std::string parm, std::string value)
+{
+	if (parm == "file")
+	{
 		// apply midi input filename
 		file = value;
-		
-	} else if(parm == "speed") {
+	}
+	else if (parm == "speed")
+	{
 		// try to apply speed
-		 try {
+		try
+		{
 			speed = std::stof(value);
-		} catch (...) {
-			std::cerr << "[MidifileInputEngine] Invalid speed "
-				<< value << "\n";
 		}
-	} else if (parm == "midimap") {
+		catch (...)
+		{
+			std::cerr << "[MidifileInputEngine] Invalid speed " << value << "\n";
+		}
+	}
+	else if (parm == "midimap")
+	{
 		// apply midimap filename
 		midimap = value;
-		
-	} else if (parm == "loop") {
+	}
+	else if (parm == "loop")
+	{
 		// apply looping
 		loop = true;
-		
-	} else {
-		std::cerr << "[MidifileInputEngine] Unsupported parameter '"
-			<< parm << "'\n";
+	}
+	else
+	{
+		std::cerr << "[MidifileInputEngine] Unsupported parameter '" << parm
+		          << "'\n";
 	}
 }
 
-bool MidifileInputEngine::start() {
-	return true;
-}
+bool MidifileInputEngine::start() { return true; }
 
-void MidifileInputEngine::stop() {
-}
+void MidifileInputEngine::stop() {}
 
-void MidifileInputEngine::pre() {
-}
+void MidifileInputEngine::pre() {}
 
-event_t* MidifileInputEngine::run(size_t pos, size_t len, size_t *nevents) {
-	event_t* evs{nullptr};
+event_t *MidifileInputEngine::run(size_t pos, size_t len, size_t *nevents)
+{
+	event_t *evs{nullptr};
 	size_t num_events{0u};
-	
+
 	double current_max_time = (1.0 + pos + len) / (44100.0 / speed);
 	current_max_time -= offset;
 	//  double cur_min_time = (double)(pos) / (44100.0 / speed);
-	
-	if(!current_event) {
+
+	if (!current_event)
+	{
 		current_event = smf_get_next_event(smf);
 	}
-	
-	while(current_event && current_event->time_seconds < current_max_time) {
-		if(!smf_event_is_metadata(current_event)) {
-			if( (current_event->midi_buffer_length == 3) &&
-				((current_event->midi_buffer[0] & NOTE_ON) == NOTE_ON) &&
-				(track == -1 || current_event->track_number == track) &&
-				current_event->midi_buffer[2] > 0) {
-				
-				if(evs == nullptr) {
-					printf("Owning raw pointer at drumgizmo/input/midifile.cc - GET RID OF THEM!\n");
+
+	while (current_event && current_event->time_seconds < current_max_time)
+	{
+		if (!smf_event_is_metadata(current_event))
+		{
+			if ((current_event->midi_buffer_length == 3) &&
+			    ((current_event->midi_buffer[0] & NOTE_ON) == NOTE_ON) &&
+			    (track == -1 || current_event->track_number == track) &&
+			    current_event->midi_buffer[2] > 0)
+			{
+
+				if (evs == nullptr)
+				{
+					printf("Owning raw pointer at drumgizmo/input/midifile.cc - GET RID "
+					       "OF THEM!\n");
 					evs = (event_t *)malloc(sizeof(event_t) * 1000);
 				}
-				
+
 				int key = current_event->midi_buffer[1];
 				int velocity = current_event->midi_buffer[2];
 
@@ -149,29 +164,37 @@ event_t* MidifileInputEngine::run(size_t pos, size_t len, size_t *nevents) {
 				evs[num_events].offset = evpos - pos;
 
 				int i = midi_mapper.lookup(key);
-				if(i != -1) {
+				if (i != -1)
+				{
 					evs[num_events].instrument = i;
 					evs[num_events].velocity = velocity / 127.0;
-        
+
 					++num_events;
-					if(num_events > 999) {
+					if (num_events > 999)
+					{
 						fprintf(stderr, "PANIC!\n");
 						break;
 					}
 				}
 			}
 		}
-    
+
 		current_event = smf_get_next_event(smf);
 	}
 
-	if(!current_event) {
-		if(loop) {
+	if (!current_event)
+	{
+		if (loop)
+		{
 			smf_rewind(smf);
 			offset += current_max_time;
-		} else {
-			if(evs == nullptr) {
-				printf("Owning raw pointer at drumgizmo/input/midifile.cc - GET RID OF THEM!\n");
+		}
+		else
+		{
+			if (evs == nullptr)
+			{
+				printf("Owning raw pointer at drumgizmo/input/midifile.cc - GET RID OF "
+				       "THEM!\n");
 				evs = (event_t *)malloc(sizeof(event_t) * 1000);
 			}
 			evs[num_events].type = TYPE_STOP;
@@ -183,5 +206,4 @@ event_t* MidifileInputEngine::run(size_t pos, size_t len, size_t *nevents) {
 	return evs;
 }
 
-void MidifileInputEngine::post() {
-}
+void MidifileInputEngine::post() {}
diff --git a/drumgizmo/input/midifile.h b/drumgizmo/input/midifile.h
index 6749339..5efcc72 100644
--- a/drumgizmo/input/midifile.h
+++ b/drumgizmo/input/midifile.h
@@ -34,31 +34,31 @@
 #include "midimapper.h"
 #include "midimapparser.h"
 
-class MidifileInputEngine
-	: public AudioInputEngine {
-	public:
-		MidifileInputEngine();
-		~MidifileInputEngine();
-		
-		// based on AudioInputEngine
-		bool isMidiEngine() override;
-		bool init(Instruments &instruments) override;
-		void setParm(std::string parm, std::string value) override;
-		bool start() override;
-		void stop() override;
-		void pre() override;
-		event_t* run(size_t pos, size_t len, size_t* nevents) override;
-		void post() override;
-		
-	private:
-		smf_t* smf;
-		smf_event_t* current_event;
-		
-		MidiMapper midi_mapper;
-		
-		std::string file, midimap;
-		float speed;
-		int track;
-		bool loop;
-		double offset;
+class MidifileInputEngine : public AudioInputEngine
+{
+public:
+	MidifileInputEngine();
+	~MidifileInputEngine();
+
+	// based on AudioInputEngine
+	bool isMidiEngine() override;
+	bool init(Instruments &instruments) override;
+	void setParm(std::string parm, std::string value) override;
+	bool start() override;
+	void stop() override;
+	void pre() override;
+	event_t *run(size_t pos, size_t len, size_t *nevents) override;
+	void post() override;
+
+private:
+	smf_t *smf;
+	smf_event_t *current_event;
+
+	MidiMapper midi_mapper;
+
+	std::string file, midimap;
+	float speed;
+	int track;
+	bool loop;
+	double offset;
 };