aboutsummaryrefslogtreecommitdiffstats
path: root/src/engine
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine')
-rw-r--r--src/engine/LearnRequest.cpp4
-rw-r--r--src/engine/Loader.cpp4
-rw-r--r--src/engine/Machine.cpp8
-rw-r--r--src/engine/Node.cpp16
-rw-r--r--src/engine/SMFDriver.cpp136
-rw-r--r--src/engine/machina/Machine.hpp1
-rw-r--r--src/engine/machina/Node.hpp14
-rw-r--r--src/engine/machina/SMFDriver.hpp7
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,
generated by cgit v1.2.1 (git 2.18.0) at 2025-05-05 14:51:27 +0000