Added node properties window.

Improved learning algorithm.


git-svn-id: http://svn.drobilla.net/lad/machina@375 a436a847-0d15-0410-975c-d299462d15a1

8 files changed, 151 insertions, 39 deletions

diff --git a/src/engine/LearnRequest.cpp b/src/engine/LearnRequest.cpp
index 6f311cb..019f7a2 100644
--- a/src/engine/LearnRequest.cpp
+++ b/src/engine/LearnRequest.cpp
@@ -25,8 +25,8 @@ namespace Machina {
 void
 LearnRequest::finish(BeatTime time)
 {
-	_node->add_enter_action(_enter_action);
-	_node->add_exit_action(_exit_action);
+	_node->set_enter_action(_enter_action);
+	_node->set_exit_action(_exit_action);
 
 	double duration = Raul::Quantizer::quantize(_quantization, time - _start_time);
 	
diff --git a/src/engine/Loader.cpp b/src/engine/Loader.cpp
index b58d150..02aff51 100644
--- a/src/engine/Loader.cpp
+++ b/src/engine/Loader.cpp
@@ -157,8 +157,8 @@ Loader::load(const Glib::ustring& uri)
 			SharedPtr<Node> node = node_i->second;
 			const long note_num = strtol(note.c_str(), NULL, 10);
 			if (note_num >= 0 && note_num <= 127) {
-				node->add_enter_action(ActionFactory::note_on((unsigned char)note_num));
-				node->add_exit_action(ActionFactory::note_off((unsigned char)note_num));
+				node->set_enter_action(ActionFactory::note_on((unsigned char)note_num));
+				node->set_exit_action(ActionFactory::note_off((unsigned char)note_num));
 			} else {
 				cerr << "WARNING:  MIDI note number out of range, ignoring." << endl;
 			}
diff --git a/src/engine/Machine.cpp b/src/engine/Machine.cpp
index f2aa845..91dcfe4 100644
--- a/src/engine/Machine.cpp
+++ b/src/engine/Machine.cpp
@@ -55,10 +55,18 @@ Machine::set_sink(SharedPtr<Raul::MIDISink> sink)
 void
 Machine::add_node(SharedPtr<Node> node)
 {
+	cerr << "ADDING NODE " << node.get() << endl;
 	_nodes.push_back(node);
 }
 
 
+void
+Machine::remove_node(SharedPtr<Node> node)
+{
+	_nodes.erase(_nodes.find(node));
+}
+
+
 /** Exit all active states and reset time to 0.
  */
 void
diff --git a/src/engine/Node.cpp b/src/engine/Node.cpp
index 4a1ded0..d94e0bc 100644
--- a/src/engine/Node.cpp
+++ b/src/engine/Node.cpp
@@ -33,14 +33,14 @@ Node::Node(BeatCount duration, bool initial)
 
 
 void
-Node::add_enter_action(SharedPtr<Action> action)
+Node::set_enter_action(SharedPtr<Action> action)
 {
 	_enter_action = action;
 }
 
 
 void
-Node::remove_enter_action(SharedPtr<Action> /*action*/)
+Node::remove_enter_action()
 {
 	_enter_action.reset();
 }
@@ -48,14 +48,14 @@ Node::remove_enter_action(SharedPtr<Action> /*action*/)
 
 
 void
-Node::add_exit_action(SharedPtr<Action> action)
+Node::set_exit_action(SharedPtr<Action> action)
 {
 	_exit_action = action;
 }
 
 
 void
-Node::remove_exit_action(SharedPtr<Action> /*action*/)
+Node::remove_exit_action()
 {
 	_exit_action.reset();
 }
@@ -65,7 +65,9 @@ Node::remove_exit_action(SharedPtr<Action> /*action*/)
 void
 Node::enter(SharedPtr<Raul::MIDISink> sink, BeatTime time)
 {
-	//cerr << "ENTER " << time << endl;
+	assert(!_is_active);
+	//std::cerr << "ENTER " << time << std::endl;
+	
 	_is_active = true;
 	_enter_time = time;
 	if (sink && _enter_action)
@@ -76,7 +78,9 @@ Node::enter(SharedPtr<Raul::MIDISink> sink, BeatTime time)
 void
 Node::exit(SharedPtr<Raul::MIDISink> sink, BeatTime time)
 {
-	//cerr << "EXIT " << time << endl;
+	assert(_is_active);
+	//std::cerr << "EXIT " << time << std::endl;
+	
 	if (sink && _exit_action)
 		_exit_action->execute(sink, time);
 	_is_active = false;
diff --git a/src/engine/SMFDriver.cpp b/src/engine/SMFDriver.cpp
index e14e04c..ff55e00 100644
--- a/src/engine/SMFDriver.cpp
+++ b/src/engine/SMFDriver.cpp
@@ -96,6 +96,54 @@ SMFDriver::learn(const string& filename, double q, Raul::BeatTime max_duration)
 }
 
 
+bool
+SMFDriver::is_delay_node(SharedPtr<Node> node) const
+{
+	if (node->enter_action() || node->exit_action())
+		return false;
+	else
+		return true;
+}
+
+
+/** Connect two nodes, inserting a delay node between them if necessary.
+ *
+ * If a delay node is added to the machine, it is returned.
+ */
+SharedPtr<Node>
+SMFDriver::connect_nodes(SharedPtr<Machine> m,
+                         SharedPtr<Node>    tail, Raul::BeatTime tail_end_time,
+                         SharedPtr<Node>    head, Raul::BeatTime head_start_time)
+{
+	assert(tail != head);
+	assert(head_start_time >= tail_end_time);
+
+	SharedPtr<Node> delay_node;
+
+	cout << "Connect nodes durations: " << tail->duration() << " .. " << head->duration() << endl;
+	cout << "Connect nodes times: " << tail_end_time << " .. " << head_start_time << endl;
+
+	if (head_start_time == tail_end_time) {
+		// Connect directly
+		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, head)));
+	} else if (is_delay_node(tail)) {
+		// Tail is a delay node, just accumulate the time difference into it
+		tail->set_duration(tail->duration() + head_start_time - tail_end_time);
+		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, head)));
+	} else {
+		// Need to actually create a delay node
+		cerr << "Adding delay node for " << tail_end_time << " .. " << head_start_time << endl;
+		delay_node = SharedPtr<Node>(new Node());
+		delay_node->set_duration(head_start_time - tail_end_time);
+		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, delay_node)));
+		delay_node->add_outgoing_edge(SharedPtr<Edge>(new Edge(delay_node, head)));
+		m->add_node(delay_node);
+	}
+
+	return delay_node;
+}
+
+
 void
 SMFDriver::learn_track(SharedPtr<Machine> m,
                        Raul::SMFReader&   reader,
@@ -107,7 +155,11 @@ SMFDriver::learn_track(SharedPtr<Machine> m,
 	if (!found_track)
 		return;
 
-	list<SharedPtr<Node> > active_nodes;
+	typedef list<SharedPtr<Node> > ActiveList;
+	ActiveList active_nodes;
+	
+	typedef list<pair<Raul::BeatTime, SharedPtr<Node> > > PolyList;
+	PolyList poly_nodes;
 	
 	SharedPtr<Node> initial_node(new Node());
 	initial_node->set_initial(true);
@@ -135,28 +187,21 @@ SMFDriver::learn_track(SharedPtr<Machine> m,
 			if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_ON) {
 				//cerr << "NOTE ON: " << (int)buf[1] << ", channel = " << (int)(buf[0] & 0x0F) << endl;
 				SharedPtr<Node> node(new Node());
-				node->add_enter_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));
-				assert(connect_node_end_time <= t);
 				
-				if (t == connect_node_end_time) {
-					connect_node->add_outgoing_edge(SharedPtr<Edge>(new Edge(connect_node, node)));
-				} else {
-					SharedPtr<Node> delay_node(new Node());
-					delay_node->set_duration(t - connect_node_end_time);
-					connect_node->add_outgoing_edge(SharedPtr<Edge>(new Edge(connect_node, delay_node)));
-					delay_node->add_outgoing_edge(SharedPtr<Edge>(new Edge(delay_node, node)));
-					m->add_node(delay_node);
-					++added_nodes;
+				node->set_enter_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));
+
+				SharedPtr<Node> delay_node = connect_nodes(m, connect_node, connect_node_end_time, node, t);
+				if (delay_node) {
 					connect_node = delay_node;
 					connect_node_end_time = t;
 				}
 
 				node->enter(SharedPtr<Raul::MIDISink>(), t);
 				active_nodes.push_back(node);
+
 			} else if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_OFF) {
 				//cerr << "NOTE OFF: " << (int)buf[1] << endl;
-				for (list<SharedPtr<Node> >::iterator i = active_nodes.begin();
-						i != active_nodes.end(); ++i) {
+				for (ActiveList::iterator i = active_nodes.begin(); i != active_nodes.end(); ++i) {
 					SharedPtr<MidiAction> action = PtrCast<MidiAction>((*i)->enter_action());
 					if (!action)
 						continue;
@@ -167,17 +212,64 @@ SMFDriver::learn_track(SharedPtr<Machine> m,
 							&& (ev[0] & 0x0F) == (buf[0] & 0x0F) // same channel
 							&& ev[1] == buf[1]) // same note
 					{
-						//cerr << "FOUND MATCHING NOTE ON!\n";
-						(*i)->add_exit_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));
-						(*i)->set_duration(t - (*i)->enter_time());
-						(*i)->exit(SharedPtr<Raul::MIDISink>(), t);
-						m->add_node((*i));
+						//cerr << "FOUND MATCHING NOTE OFF!\n";
+
+						SharedPtr<Node> resolved = *i;
+
+						resolved->set_exit_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));
+						resolved->set_duration(t - resolved->enter_time());
+
 						++added_nodes;
+							
+						connect_node_end_time = t;
+						
 						if (active_nodes.size() == 1) {
-							connect_node = (*i);
-							connect_node_end_time = t;
+							if (poly_nodes.size() > 0) {
+								
+								connect_node = SharedPtr<Node>(new Node());
+								m->add_node(connect_node);
+									
+								connect_nodes(m, resolved, t, connect_node, t);
+								
+								for (PolyList::iterator j = poly_nodes.begin();
+										j != poly_nodes.end(); ++j) {
+									m->add_node(j->second);
+									connect_nodes(m, j->second, j->first + j->second->duration(),
+											connect_node, t);
+								}
+								poly_nodes.clear();
+							
+								m->add_node(resolved);
+								
+							} else {
+								// Trim useless delay node, if possible
+								// (these happen after polyphonic sections)
+								if (is_delay_node(connect_node) && connect_node->duration() == 0
+										&& connect_node->outgoing_edges().size() == 1
+										&& (*connect_node->outgoing_edges().begin())->dst() == resolved) {
+									connect_node->outgoing_edges().clear();
+									assert(connect_node->outgoing_edges().empty());
+									connect_node->set_enter_action(resolved->enter_action());
+									connect_node->set_exit_action(resolved->exit_action());
+									resolved->remove_enter_action();
+									resolved->remove_exit_action();
+									connect_node->set_duration(resolved->duration());
+									resolved = connect_node;
+								} else {
+									connect_node = resolved;
+									m->add_node(resolved);
+								}
+							} 
+
+						} else {
+							poly_nodes.push_back(make_pair(resolved->enter_time(), resolved));
 						}
+						
+						if (resolved->is_active())
+							resolved->exit(SharedPtr<Raul::MIDISink>(), t);
+						
 						active_nodes.erase(i);
+
 						break;
 					}
 				}
@@ -197,7 +289,7 @@ SMFDriver::learn_track(SharedPtr<Machine> m,
 			const unsigned char* ev      = action->event();
 			if (ev_size == 3 && (ev[0] & 0xF0) == MIDI_CMD_NOTE_ON) {
 				unsigned char note_off[3] = { ((MIDI_CMD_NOTE_OFF & 0xF0) | (ev[0] & 0x0F)), ev[1], 0x40 };
-				(*i)->add_exit_action(SharedPtr<Action>(new MidiAction(3, note_off)));
+				(*i)->set_exit_action(SharedPtr<Action>(new MidiAction(3, note_off)));
 				(*i)->set_duration(t - (*i)->enter_time());
 				(*i)->exit(SharedPtr<Raul::MIDISink>(), t);
 				m->add_node((*i));
diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp
index b8e371d..e5bef23 100644
--- a/src/engine/machina/Machine.hpp
+++ b/src/engine/machina/Machine.hpp
@@ -43,6 +43,7 @@ public:
 	bool is_finished() { return _is_finished; }
 
 	void add_node(SharedPtr<Node> node);
+	void remove_node(SharedPtr<Node> node);
 	void learn(SharedPtr<LearnRequest> learn);
 
 	void write_state(Raul::RDFWriter& writer);
diff --git a/src/engine/machina/Node.hpp b/src/engine/machina/Node.hpp
index 2f9c2e4..5181149 100644
--- a/src/engine/machina/Node.hpp
+++ b/src/engine/machina/Node.hpp
@@ -46,11 +46,11 @@ public:
 
 	Node(BeatCount duration=0, bool initial=false);
 
-	void add_enter_action(SharedPtr<Action> action);
-	void remove_enter_action(SharedPtr<Action> action);
+	void set_enter_action(SharedPtr<Action> action);
+	void remove_enter_action();
 
-	void add_exit_action(SharedPtr<Action> action);
-	void remove_exit_action(SharedPtr<Action> action);
+	void set_exit_action(SharedPtr<Action> action);
+	void remove_exit_action();
 
 	SharedPtr<Action> enter_action() { return _enter_action; }
 	SharedPtr<Action> exit_action()  { return _exit_action; }
@@ -67,13 +67,13 @@ public:
 	bool      is_initial() const        { return _is_initial; }
 	void      set_initial(bool i)       { _is_initial = i; }
 	bool      is_active() const         { return _is_active; }
-	BeatTime  enter_time() const        { return _enter_time; }
-	BeatTime  exit_time() const         { return _enter_time + _duration; }
+	BeatTime  enter_time() const        { assert(_is_active); return _enter_time; }
+	BeatTime  exit_time() const         { assert(_is_active); return _enter_time + _duration; }
 	BeatCount duration()                { return _duration; }
 	void      set_duration(BeatCount d) { _duration = d; }
 	
 	typedef Raul::List<SharedPtr<Edge> > Edges;
-	const Edges& outgoing_edges() const { return _outgoing_edges; }
+	Edges& outgoing_edges() { return _outgoing_edges; }
 	
 private:
 	bool              _is_initial;
diff --git a/src/engine/machina/SMFDriver.hpp b/src/engine/machina/SMFDriver.hpp
index 090eb02..7fec256 100644
--- a/src/engine/machina/SMFDriver.hpp
+++ b/src/engine/machina/SMFDriver.hpp
@@ -55,6 +55,13 @@ public:
 private:
 	SharedPtr<Raul::SMFWriter> _writer;
 
+	bool is_delay_node(SharedPtr<Node> node) const;
+
+	SharedPtr<Node>
+	connect_nodes(SharedPtr<Machine> m,
+                  SharedPtr<Node>    tail, Raul::BeatTime tail_end_time,
+     	          SharedPtr<Node>    head, Raul::BeatTime head_start_time);
+	
 	void learn_track(SharedPtr<Machine> machine,
 	                 Raul::SMFReader&   reader,
 	                 unsigned           track,