From bd92c37ed3513ab881cad3e8667c6e9c6af0858f Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 9 Feb 2008 18:23:57 +0000 Subject: Use Raul::TimeStamp (LV2 compatible typed 32:32 fixed timestamp) everywhere. Fix initial size of Patchage messages window. Machina disabled for now (transitioning to generic timestamps). git-svn-id: http://svn.drobilla.net/lad/machina@1133 a436a847-0d15-0410-975c-d299462d15a1 --- src/engine/Engine.cpp | 4 +-- src/engine/JackDriver.cpp | 30 ++++++++++++++--------- src/engine/LearnRequest.cpp | 4 +-- src/engine/Loader.cpp | 10 +++++--- src/engine/Machine.cpp | 28 ++++++++++----------- src/engine/MachineBuilder.cpp | 46 +++++++++++++++++------------------ src/engine/MidiAction.cpp | 2 +- src/engine/Mutation.cpp | 2 +- src/engine/Node.cpp | 12 ++++----- src/engine/Recorder.cpp | 12 ++++----- src/engine/SMFDriver.cpp | 36 ++++++++++++++------------- src/engine/machina/Action.hpp | 4 +-- src/engine/machina/Driver.hpp | 2 +- src/engine/machina/Engine.hpp | 3 +-- src/engine/machina/JackDriver.hpp | 14 +++++------ src/engine/machina/LearnRequest.hpp | 10 +++++--- src/engine/machina/Machine.hpp | 10 ++++---- src/engine/machina/MachineBuilder.hpp | 21 ++++++++-------- src/engine/machina/MidiAction.hpp | 2 +- src/engine/machina/Node.hpp | 33 +++++++++++++------------ src/engine/machina/Recorder.hpp | 13 +++++----- src/engine/machina/SMFDriver.hpp | 16 ++++++------ 22 files changed, 161 insertions(+), 153 deletions(-) (limited to 'src/engine') diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 1a2fe56..0724018 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -67,10 +67,10 @@ Engine::import_machine(const Glib::ustring& uri) * Safe to call while engine is processing. */ SharedPtr -Engine::import_midi(const Glib::ustring& uri, Raul::BeatTime duration) +Engine::import_midi(const Glib::ustring& uri, Raul::TimeStamp q, Raul::TimeDuration duration) { SharedPtr file_driver(new SMFDriver()); - SharedPtr m = file_driver->learn(uri, duration); + SharedPtr m = file_driver->learn(uri, q, duration); m->activate(); _driver->machine()->nodes().append(m->nodes()); diff --git a/src/engine/JackDriver.cpp b/src/engine/JackDriver.cpp index 2e588ec..5560926 100644 --- a/src/engine/JackDriver.cpp +++ b/src/engine/JackDriver.cpp @@ -35,11 +35,10 @@ JackDriver::JackDriver(SharedPtr machine) , _output_port(NULL) , _cycle_time(1/48000.0, 120.0) , _bpm(120.0) - , _quantization(0.0) + , _quantization(machine->time().unit()) + , _record_time(machine->time().unit()) , _recording(0) { - if (!_machine) - _machine = SharedPtr(new Machine()); } @@ -74,6 +73,10 @@ JackDriver::attach(const std::string& client_name) if (!_output_port) std::cerr << "WARNING: Failed to create MIDI output port." << std::endl; + if (!_machine) + _machine = SharedPtr(new Machine( + TimeUnit::frames(jack_get_sample_rate(jack_client())))); + _machine->activate(); } } @@ -119,12 +122,12 @@ void JackDriver::process_input(SharedPtr machine, const TimeSlice& time) { // We only actually read Jack input at the beginning of a cycle - assert(time.offset_ticks() == 0); + assert(time.offset_ticks().is_zero()); assert(_input_port); if (_recording.get()) { - const jack_nframes_t nframes = time.length_ticks(); + const jack_nframes_t nframes = time.length_ticks().ticks(); void* jack_buffer = jack_port_get_buffer(_input_port, nframes); const jack_nframes_t event_count = jack_midi_get_event_count(jack_buffer); @@ -132,7 +135,8 @@ JackDriver::process_input(SharedPtr machine, const TimeSlice& time) jack_midi_event_t ev; jack_midi_event_get(&ev, jack_buffer, i); - _recorder->write(_record_time + ev.time, ev.size, ev.buffer); + _recorder->write(_record_time + TimeStamp(_record_time.unit(), ev.time, 0), + ev.size, ev.buffer); } if (event_count > 0) @@ -140,7 +144,7 @@ JackDriver::process_input(SharedPtr machine, const TimeSlice& time) } else { - const jack_nframes_t nframes = time.length_ticks(); + const jack_nframes_t nframes = time.length_ticks().ticks(); void* jack_buffer = jack_port_get_buffer(_input_port, nframes); const jack_nframes_t event_count = jack_midi_get_event_count(jack_buffer); @@ -154,7 +158,8 @@ JackDriver::process_input(SharedPtr machine, const TimeSlice& time) if (learn) { learn->enter_action()->set_event(ev.size, ev.buffer); learn->start(_quantization.get(), - time.ticks_to_beats(jack_last_frame_time(_client) + ev.time)); + TimeStamp(TimeUnit::frames(sample_rate()), + jack_last_frame_time(_client) + ev.time, 0)); } } else if (ev.buffer[0] == 0x80) { @@ -165,7 +170,8 @@ JackDriver::process_input(SharedPtr machine, const TimeSlice& time) if (learn->started()) { learn->exit_action()->set_event(ev.size, ev.buffer); learn->finish( - time.ticks_to_beats(jack_last_frame_time(_client) + ev.time)); + TimeStamp(TimeUnit::frames(sample_rate()), + jack_last_frame_time(_client) + ev.time, 0)); machine->clear_pending_learn(); } } @@ -177,9 +183,9 @@ JackDriver::process_input(SharedPtr machine, const TimeSlice& time) void -JackDriver::write_event(Raul::BeatTime time, - size_t size, - const byte* event) throw (std::logic_error) +JackDriver::write_event(Raul::TimeStamp time, + size_t size, + const byte* event) throw (std::logic_error) { if (!_output_port) return; diff --git a/src/engine/LearnRequest.cpp b/src/engine/LearnRequest.cpp index f4d88f0..2bcd719 100644 --- a/src/engine/LearnRequest.cpp +++ b/src/engine/LearnRequest.cpp @@ -23,12 +23,12 @@ namespace Machina { /** Add the learned actions to the node */ void -LearnRequest::finish(BeatTime time) +LearnRequest::finish(TimeStamp time) { _node->set_enter_action(_enter_action); _node->set_exit_action(_exit_action); - double duration = Raul::Quantizer::quantize(_quantization, time - _start_time); + TimeDuration duration = Raul::Quantizer::quantize(_quantization, time - _start_time); _node->set_duration(duration); } diff --git a/src/engine/Loader.cpp b/src/engine/Loader.cpp index cf41bd1..3cc93aa 100644 --- a/src/engine/Loader.cpp +++ b/src/engine/Loader.cpp @@ -74,7 +74,7 @@ Loader::load(const Glib::ustring& uri) cout << "[Loader] Loading " << machine_uri << " from " << document_uri << endl; - machine = SharedPtr(new Machine()); + machine = SharedPtr(new Machine(TimeUnit::beats(LV2_EVENT_PPQN))); typedef std::map > Created; Created created; @@ -93,7 +93,9 @@ Loader::load(const Glib::ustring& uri) for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) { const char* node_id = (*i)["node"]; - SharedPtr node(new Node(float((*i)["duration"]), true)); + SharedPtr node(new Node( + TimeStamp(TimeUnit(TimeUnit::BEATS, LV2_EVENT_PPQN), (double)(*i)["duration"]), + true)); machine->add_node(node); created[node_id] = node; } @@ -112,7 +114,9 @@ Loader::load(const Glib::ustring& uri) for (Query::Results::iterator i = results.begin(); i != results.end(); ++i) { const char* node_id = (*i)["node"]; if (created.find(node_id) == created.end()) { - SharedPtr node(new Node((float)(*i)["duration"], false)); + SharedPtr node(new Node( + TimeStamp(TimeUnit(TimeUnit::BEATS, LV2_EVENT_PPQN), (double)(*i)["duration"]), + false)); machine->add_node(node); created[node_id] = node; } diff --git a/src/engine/Machine.cpp b/src/engine/Machine.cpp index 3a1283d..23bf1f8 100644 --- a/src/engine/Machine.cpp +++ b/src/engine/Machine.cpp @@ -30,11 +30,11 @@ using namespace Raul; namespace Machina { -Machine::Machine() +Machine::Machine(TimeUnit unit) : _active_nodes(MAX_ACTIVE_NODES, SharedPtr()) , _is_activated(false) , _is_finished(false) - , _time(0) + , _time(unit) { } @@ -49,7 +49,7 @@ Machine::Machine(const Machine& copy) , _active_nodes(MAX_ACTIVE_NODES, SharedPtr()) , _is_activated(false) , _is_finished(false) - , _time(0) + , _time(copy.time().unit()) , _sink(copy._sink) { map< SharedPtr, SharedPtr > replacements; @@ -165,7 +165,7 @@ Machine::remove_node(SharedPtr node) /** Exit all active states and reset time to 0. */ void -Machine::reset(Raul::BeatTime time) +Machine::reset(Raul::TimeStamp time) { if (!_is_finished) { for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { @@ -299,27 +299,26 @@ Machine::exit_node(SharedPtr sink, SharedPtr node) * machine actually finished on (so it can be restarted immediately * with sample accuracy if necessary). */ -BeatCount +TimeDuration Machine::run(const Raul::TimeSlice& time) { if (_is_finished) - return 0; + return TimeDuration(_time.unit(), 0, 0); SharedPtr sink = _sink.lock(); - const TickTime cycle_end_ticks = time.start_ticks() + time.length_ticks() - 1; - const BeatCount cycle_end_beats = time.ticks_to_beats(cycle_end_ticks); + const TimeStamp cycle_end = time.start_ticks() + time.length_ticks(); assert(_is_activated); // Initial run, enter all initial states - if (_time == 0) { + if (_time.is_zero()) { bool entered = false; if ( ! _nodes.empty()) { for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { if ((*n)->is_active()) - (*n)->exit(sink, 0); + (*n)->exit(sink, _time); if ((*n)->is_initial()) { if (enter_node(sink, (*n))) @@ -330,11 +329,11 @@ Machine::run(const Raul::TimeSlice& time) } if (!entered) { _is_finished = true; - return 0; + return TimeStamp(_time.unit(), 0, 0); } } - BeatCount this_time = 0; + TimeStamp this_time(_time.unit(), 0, 0); while (true) { @@ -350,8 +349,7 @@ Machine::run(const Raul::TimeSlice& time) break; // Earliest active state ends this cycle - } else if (time.beats_to_ticks(earliest->exit_time()) - <= cycle_end_ticks) { + } else if (earliest->exit_time() <= cycle_end) { this_time += earliest->exit_time() - _time; _time = time.ticks_to_beats( time.beats_to_ticks(earliest->exit_time())); @@ -359,7 +357,7 @@ Machine::run(const Raul::TimeSlice& time) // Earliest active state ends in the future, done this cycle } else { - _time = cycle_end_beats; + _time = cycle_end; this_time = time.length_beats(); // ran the entire cycle break; } diff --git a/src/engine/MachineBuilder.cpp b/src/engine/MachineBuilder.cpp index 34e45b8..206df5d 100644 --- a/src/engine/MachineBuilder.cpp +++ b/src/engine/MachineBuilder.cpp @@ -29,26 +29,24 @@ using namespace Raul; namespace Machina { -MachineBuilder::MachineBuilder(SharedPtr machine, Raul::BeatTime q) +MachineBuilder::MachineBuilder(SharedPtr machine, Raul::TimeStamp q) : _quantization(q) - , _time(0) + , _time(machine->time().unit()) // = 0 , _machine(machine) - , _initial_node(new Node()) + , _initial_node(new Node(_time, true)) // duration 0 , _connect_node(_initial_node) - , _connect_node_end_time(0) + , _connect_node_end_time(_time) // = 0 { - _initial_node->set_initial(true); } void MachineBuilder::reset() { - _initial_node = SharedPtr(new Node(0.0)); - _initial_node->set_initial(true); + _time = TimeStamp(_machine->time().unit()); // = 0 + _initial_node = SharedPtr(new Node(_time, true)); // duration 0 _connect_node = _initial_node; - _connect_node_end_time = 0; - _time = 0; + _connect_node_end_time = _time; // = 0 } @@ -65,12 +63,12 @@ MachineBuilder::is_delay_node(SharedPtr node) const /** Set the duration of a node, with quantization. */ void -MachineBuilder::set_node_duration(SharedPtr node, Raul::BeatTime d) const +MachineBuilder::set_node_duration(SharedPtr node, Raul::TimeStamp d) const { - Raul::BeatTime q_dur = Quantizer::quantize(_quantization, d); + Raul::TimeStamp q_dur = Quantizer::quantize(_quantization, d); // Never quantize a note to duration 0 - if (q_dur == 0 && ( node->enter_action() || node->exit_action() )) + if (q_dur.is_zero() && ( node->enter_action() || node->exit_action() )) q_dur = _quantization; // Round up node->set_duration(q_dur); @@ -83,8 +81,8 @@ MachineBuilder::set_node_duration(SharedPtr node, Raul::BeatTime d) const */ SharedPtr MachineBuilder::connect_nodes(SharedPtr m, - SharedPtr tail, Raul::BeatTime tail_end_time, - SharedPtr head, Raul::BeatTime head_start_time) + SharedPtr tail, Raul::TimeStamp tail_end_time, + SharedPtr head, Raul::TimeStamp head_start_time) { assert(tail != head); assert(head_start_time >= tail_end_time); @@ -100,8 +98,7 @@ MachineBuilder::connect_nodes(SharedPtr m, tail->add_edge(SharedPtr(new Edge(tail, head))); } else { // Need to actually create a delay node - delay_node = SharedPtr(new Node()); - set_node_duration(delay_node, head_start_time - tail_end_time); + delay_node = SharedPtr(new Node(head_start_time - tail_end_time)); tail->add_edge(SharedPtr(new Edge(tail, delay_node))); delay_node->add_edge(SharedPtr(new Edge(delay_node, head))); m->add_node(delay_node); @@ -112,22 +109,23 @@ MachineBuilder::connect_nodes(SharedPtr m, void -MachineBuilder::event(Raul::BeatTime time_offset, - size_t ev_size, - unsigned char* buf) +MachineBuilder::event(Raul::TimeStamp time_offset, + size_t ev_size, + unsigned char* buf) { - Raul::BeatTime t = _time + time_offset; + const Raul::TimeUnit unit = time_offset.unit(); + Raul::TimeStamp t = _time + time_offset; if (ev_size == 0) return; if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_ON) { - SharedPtr node(new Node(0.0)); + SharedPtr node(new Node(TimeStamp(unit))); node->set_enter_action(SharedPtr(new MidiAction(ev_size, buf))); SharedPtr this_connect_node; - Raul::BeatTime this_connect_node_end_time; + Raul::TimeStamp this_connect_node_end_time(unit); // If currently polyphonic, use a poly node with no successors as connect node // Results in patterns closes to what a human would choose @@ -187,7 +185,7 @@ MachineBuilder::event(Raul::BeatTime time_offset, // Finish a polyphonic section if (_poly_nodes.size() > 0) { - _connect_node = SharedPtr(new Node(0.0)); + _connect_node = SharedPtr(new Node(TimeStamp(unit))); _machine->add_node(_connect_node); connect_nodes(_machine, resolved, t, _connect_node, t); @@ -206,7 +204,7 @@ MachineBuilder::event(Raul::BeatTime time_offset, } else { // Trim useless delay node if possible (these appear after poly sections) - if (is_delay_node(_connect_node) && _connect_node->duration() == 0 + if (is_delay_node(_connect_node) && _connect_node->duration().is_zero() && _connect_node->edges().size() == 1 && (*_connect_node->edges().begin())->head() == resolved) { diff --git a/src/engine/MidiAction.cpp b/src/engine/MidiAction.cpp index b17c5b9..bad3fc0 100644 --- a/src/engine/MidiAction.cpp +++ b/src/engine/MidiAction.cpp @@ -78,7 +78,7 @@ MidiAction::set_event(size_t size, const byte* new_event) * Safe to call concurrently with set_event. */ void -MidiAction::execute(SharedPtr sink, Raul::BeatTime time) +MidiAction::execute(SharedPtr sink, Raul::TimeStamp time) { const byte* const event = _event.get(); diff --git a/src/engine/Mutation.cpp b/src/engine/Mutation.cpp index a307ce5..8c8c245 100644 --- a/src/engine/Mutation.cpp +++ b/src/engine/Mutation.cpp @@ -52,7 +52,7 @@ AddNode::mutate(Machine& machine) //cout << "ADD NODE" << endl; // Create random node - SharedPtr node(new Node()); + SharedPtr node(new Node(machine.time().unit())); node->set_selector(true); SharedPtr note_node = machine.random_node(); diff --git a/src/engine/Node.cpp b/src/engine/Node.cpp index 56bfac5..f24c4be 100644 --- a/src/engine/Node.cpp +++ b/src/engine/Node.cpp @@ -29,11 +29,11 @@ using namespace Raul; namespace Machina { -Node::Node(BeatCount duration, bool initial) +Node::Node(TimeDuration duration, bool initial) : _is_initial(initial) , _is_selector(false) , _is_active(false) - , _enter_time(0) + , _enter_time(duration.unit()) , _duration(duration) { } @@ -44,7 +44,7 @@ Node::Node(const Node& copy) , _is_initial(copy._is_initial) , _is_selector(copy._is_selector) , _is_active(false) - , _enter_time(0) + , _enter_time(copy.enter_time()) , _duration(copy._duration) , _enter_action(ActionFactory::copy(copy._enter_action)) , _exit_action(ActionFactory::copy(copy._exit_action)) @@ -126,7 +126,7 @@ Node::set_exit_action(SharedPtr action) void -Node::enter(SharedPtr sink, BeatTime time) +Node::enter(SharedPtr sink, TimeStamp time) { assert(!_is_active); @@ -140,7 +140,7 @@ Node::enter(SharedPtr sink, BeatTime time) void -Node::exit(SharedPtr sink, BeatTime time) +Node::exit(SharedPtr sink, TimeStamp time) { assert(_is_active); @@ -221,7 +221,7 @@ Node::write_state(Redland::Model& model) model.add_statement(_id, "machina:duration", - AtomRDF::atom_to_node(model.world(), Atom((float)_duration))); + AtomRDF::atom_to_node(model.world(), Atom((float)_duration.to_double()))); if (_enter_action) { _enter_action->write_state(model); diff --git a/src/engine/Recorder.cpp b/src/engine/Recorder.cpp index 1fd8ee4..302a66e 100644 --- a/src/engine/Recorder.cpp +++ b/src/engine/Recorder.cpp @@ -26,10 +26,10 @@ using namespace Raul; namespace Machina { -Recorder::Recorder(size_t buffer_size, double tick_rate, double q) - : _tick_rate(tick_rate) +Recorder::Recorder(size_t buffer_size, TimeUnit unit, TimeStamp q) + : _unit(unit) , _record_buffer(buffer_size) - , _builder(new MachineBuilder(SharedPtr(new Machine()), q)) + , _builder(new MachineBuilder(SharedPtr(new Machine(unit)), q)) { } @@ -37,13 +37,13 @@ Recorder::Recorder(size_t buffer_size, double tick_rate, double q) void Recorder::_whipped() { - TickTime t; + TimeStamp t(_unit); size_t size; unsigned char buf[4]; while (_record_buffer.read(&t, &size, buf)) { - _builder->set_time(t * _tick_rate); - _builder->event(0, size, buf); + _builder->set_time(t); + _builder->event(TimeStamp(_unit), size, buf); } } diff --git a/src/engine/SMFDriver.cpp b/src/engine/SMFDriver.cpp index 85aa8ab..776339c 100644 --- a/src/engine/SMFDriver.cpp +++ b/src/engine/SMFDriver.cpp @@ -34,7 +34,7 @@ namespace Machina { SMFDriver::SMFDriver(SharedPtr machine) : Driver(machine) { - _writer = SharedPtr(new Raul::SMFWriter()); + _writer = SharedPtr(new Raul::SMFWriter(machine->time().unit())); } @@ -46,9 +46,10 @@ SMFDriver::SMFDriver(SharedPtr machine) * @return the resulting machine. */ SharedPtr -SMFDriver::learn(const string& filename, unsigned track, double q, Raul::BeatTime max_duration) +SMFDriver::learn(const string& filename, unsigned track, Raul::TimeStamp q, Raul::TimeDuration max_duration) { - SharedPtr m(new Machine()); + assert(q.unit() == max_duration.unit()); + SharedPtr m(new Machine(max_duration.unit())); SharedPtr builder = SharedPtr(new MachineBuilder(m, q)); Raul::SMFReader reader; @@ -76,9 +77,9 @@ SMFDriver::learn(const string& filename, unsigned track, double q, Raul::BeatTim * This will result in one disjoint subgraph in the machine for each track. */ SharedPtr -SMFDriver::learn(const string& filename, double q, Raul::BeatTime max_duration) +SMFDriver::learn(const string& filename, Raul::TimeStamp q, Raul::TimeStamp max_duration) { - SharedPtr m(new Machine()); + SharedPtr m(new Machine(q.unit())); SharedPtr builder = SharedPtr(new MachineBuilder(m, q)); Raul::SMFReader reader; @@ -105,29 +106,29 @@ void SMFDriver::learn_track(SharedPtr builder, Raul::SMFReader& reader, unsigned track, - double q, - Raul::BeatTime max_duration) + Raul::TimeStamp q, + Raul::TimeDuration max_duration) { const bool found_track = reader.seek_to_track(track); if (!found_track) return; - Raul::BeatTime unquantized_t = 0; - Raul::BeatTime t = 0; - unsigned char buf[4]; - uint32_t ev_size; - uint32_t ev_time; + Raul::TimeStamp unquantized_t(q.unit(), 0, 0); + Raul::TimeStamp t(q.unit(), 0, 0); + unsigned char buf[4]; + uint32_t ev_size; + Raul::TimeStamp ev_time(q.unit()); while (reader.read_event(4, buf, &ev_size, &ev_time) >= 0) { - unquantized_t += ev_time / (double)reader.ppqn(); + unquantized_t += ev_time; t = Raul::Quantizer::quantize(q, unquantized_t); builder->set_time(t); - if (max_duration != 0 && t > max_duration) + if ((!max_duration.is_zero()) && t > max_duration) break; if (ev_size > 0) - builder->event(0, ev_size, buf); + builder->event(TimeStamp(t.unit(), 0, 0), ev_size, buf); } builder->resolve(); @@ -135,9 +136,10 @@ SMFDriver::learn_track(SharedPtr builder, void -SMFDriver::run(SharedPtr machine, Raul::BeatTime max_time) +SMFDriver::run(SharedPtr machine, Raul::TimeStamp max_time) { - Raul::TimeSlice time(1.0/(double)_writer->ppqn(), 120); + // FIXME: unit kludge (tempo only) + Raul::TimeSlice time(1.0/(double)_writer->unit().ppt(), 120); time.set_length(time.beats_to_ticks(max_time)); machine->set_sink(shared_from_this()); machine->run(time); diff --git a/src/engine/machina/Action.hpp b/src/engine/machina/Action.hpp index 3cab3ee..1d1700d 100644 --- a/src/engine/machina/Action.hpp +++ b/src/engine/machina/Action.hpp @@ -32,7 +32,7 @@ namespace Machina { /** An Action, executed on entering or exiting of a state. */ struct Action : public Raul::Deletable, public Raul::Stateful { - virtual void execute(SharedPtr sink, Raul::BeatTime time) = 0; + virtual void execute(SharedPtr sink, Raul::TimeStamp time) = 0; virtual void write_state(Redland::Model& model); }; @@ -42,7 +42,7 @@ class PrintAction : public Action { public: PrintAction(const std::string& msg) : _msg(msg) {} - void execute(SharedPtr, Raul::BeatTime time) + void execute(SharedPtr, Raul::TimeStamp time) { std::cout << "t=" << time << ": " << _msg << std::endl; } private: diff --git a/src/engine/machina/Driver.hpp b/src/engine/machina/Driver.hpp index e497356..31d8a9c 100644 --- a/src/engine/machina/Driver.hpp +++ b/src/engine/machina/Driver.hpp @@ -34,7 +34,7 @@ public: virtual void set_machine(SharedPtr machine) { _machine = machine; } virtual void set_bpm(double bpm) = 0; - virtual void set_quantization(double quantization) = 0; + virtual void set_quantization(Raul::TimeStamp q) = 0; virtual void activate() {} virtual void deactivate() {} diff --git a/src/engine/machina/Engine.hpp b/src/engine/machina/Engine.hpp index effa4be..763b9a8 100644 --- a/src/engine/machina/Engine.hpp +++ b/src/engine/machina/Engine.hpp @@ -20,7 +20,6 @@ #include #include -#include #include "machina/Driver.hpp" #include "machina/Loader.hpp" @@ -45,7 +44,7 @@ public: SharedPtr load_machine(const Glib::ustring& uri); SharedPtr import_machine(const Glib::ustring& uri); - SharedPtr import_midi(const Glib::ustring& uri, Raul::BeatTime d); + SharedPtr import_midi(const Glib::ustring& uri, Raul::TimeStamp q, Raul::TimeDuration d); void set_bpm(double bpm); void set_quantization(double beat_fraction); diff --git a/src/engine/machina/JackDriver.hpp b/src/engine/machina/JackDriver.hpp index 017d867..7fb5351 100644 --- a/src/engine/machina/JackDriver.hpp +++ b/src/engine/machina/JackDriver.hpp @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include #include #include @@ -56,12 +56,12 @@ public: void set_machine(SharedPtr machine); - void write_event(Raul::BeatTime time, + void write_event(Raul::TimeStamp time, size_t size, const unsigned char* event) throw (std::logic_error); - void set_bpm(double bpm) { _bpm.set(bpm); } - void set_quantization(double quantization) { _quantization.set(quantization); } + void set_bpm(double bpm) { _bpm.set(bpm); } + void set_quantization(Raul::TimeStamp q) { _quantization.set(q); } void stop(); @@ -83,12 +83,12 @@ private: Raul::TimeSlice _cycle_time; - Raul::DoubleBuffer _bpm; - Raul::DoubleBuffer _quantization; + Raul::DoubleBuffer _bpm; + Raul::DoubleBuffer _quantization; Raul::Command _stop; - Raul::TickTime _record_time; + Raul::TimeStamp _record_time; Raul::AtomicInt _recording; SharedPtr _recorder; }; diff --git a/src/engine/machina/LearnRequest.hpp b/src/engine/machina/LearnRequest.hpp index f6bc60f..1d36057 100644 --- a/src/engine/machina/LearnRequest.hpp +++ b/src/engine/machina/LearnRequest.hpp @@ -43,10 +43,10 @@ public: return ret; } - void start(double q, BeatTime time) + void start(TimeStamp q, Raul::TimeStamp time) { _started = true; _start_time = time; _quantization = q; } - void finish(BeatTime time); + void finish(TimeStamp time); bool started() { return _started; } @@ -57,6 +57,8 @@ public: private: LearnRequest(SharedPtr maid, SharedPtr node) : _started(false) + , _start_time(TimeUnit(TimeUnit::BEATS, 19200), 0, 0) // irrelevant + , _quantization(TimeUnit(TimeUnit::BEATS, 19200), 1, 0) // irrelevant , _node(node) , _enter_action(new MidiAction(4, NULL)) , _exit_action(new MidiAction(4, NULL)) @@ -66,8 +68,8 @@ private: } bool _started; - BeatTime _start_time; - double _quantization; + TimeStamp _start_time; + TimeStamp _quantization; SharedPtr _node; SharedPtr _enter_action; SharedPtr _exit_action; diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp index 5c4df36..dae8b75 100644 --- a/src/engine/machina/Machine.hpp +++ b/src/engine/machina/Machine.hpp @@ -36,7 +36,7 @@ namespace Machina { */ class Machine : public Raul::Stateful { public: - Machine(); + Machine(TimeUnit unit); Machine(const Machine& copy); Machine& operator=(const Machine& other); @@ -59,11 +59,11 @@ public: void write_state(Redland::Model& model); // Audio context - void reset(Raul::BeatTime time); - BeatCount run(const Raul::TimeSlice& time); + void reset(Raul::TimeStamp time); + TimeDuration run(const Raul::TimeSlice& time); // Any context - inline Raul::BeatTime time() const { return _time; } + inline Raul::TimeStamp time() const { return _time; } SharedPtr pending_learn() { return _pending_learn; } void clear_pending_learn() { _pending_learn.reset(); } @@ -89,7 +89,7 @@ private: bool _is_activated; bool _is_finished; - Raul::BeatTime _time; + Raul::TimeStamp _time; SharedPtr _pending_learn; WeakPtr _sink; Nodes _nodes; diff --git a/src/engine/machina/MachineBuilder.hpp b/src/engine/machina/MachineBuilder.hpp index c7b5def..58d1eb4 100644 --- a/src/engine/machina/MachineBuilder.hpp +++ b/src/engine/machina/MachineBuilder.hpp @@ -19,7 +19,6 @@ #define MACHINA_MACHINEBUILDER_HPP #include -#include #include namespace Machina { @@ -31,11 +30,11 @@ class Node; class MachineBuilder { public: MachineBuilder(SharedPtr machine, - Raul::BeatTime quantization); + Raul::TimeStamp quantization); - void set_time(Raul::BeatTime time) { _time = time; } + void set_time(Raul::TimeStamp time) { _time = time; } - void event(Raul::BeatTime time_offset, size_t size, unsigned char* buf); + void event(Raul::TimeStamp time_offset, size_t size, unsigned char* buf); void reset(); void resolve(); @@ -44,26 +43,26 @@ public: private: bool is_delay_node(SharedPtr node) const; - void set_node_duration(SharedPtr node, Raul::BeatTime d) const; + void set_node_duration(SharedPtr node, Raul::TimeStamp d) const; SharedPtr connect_nodes(SharedPtr m, - SharedPtr tail, Raul::BeatTime tail_end_time, - SharedPtr head, Raul::BeatTime head_start_time); + SharedPtr tail, Raul::TimeStamp tail_end_time, + SharedPtr head, Raul::TimeStamp head_start_time); typedef std::list > ActiveList; ActiveList _active_nodes; - typedef std::list > > PolyList; + typedef std::list > > PolyList; PolyList _poly_nodes; - Raul::BeatTime _quantization; - Raul::BeatTime _time; + Raul::TimeStamp _quantization; + Raul::TimeStamp _time; SharedPtr _machine; SharedPtr _initial_node; SharedPtr _connect_node; - Raul::BeatTime _connect_node_end_time; + Raul::TimeStamp _connect_node_end_time; }; diff --git a/src/engine/machina/MidiAction.hpp b/src/engine/machina/MidiAction.hpp index 1a3f176..57dd242 100644 --- a/src/engine/machina/MidiAction.hpp +++ b/src/engine/machina/MidiAction.hpp @@ -40,7 +40,7 @@ public: bool set_event(size_t size, const byte* event); - void execute(SharedPtr driver, Raul::BeatTime time); + void execute(SharedPtr driver, Raul::TimeStamp time); virtual void write_state(Redland::Model& model); diff --git a/src/engine/machina/Node.hpp b/src/engine/machina/Node.hpp index 324ec29..446db96 100644 --- a/src/engine/machina/Node.hpp +++ b/src/engine/machina/Node.hpp @@ -28,8 +28,9 @@ namespace Machina { class Edge; -using Raul::BeatCount; -using Raul::BeatTime; +using Raul::TimeDuration; +using Raul::TimeStamp; +using Raul::TimeUnit; /** A node is a state (as in a FSM diagram), or "note". @@ -44,7 +45,7 @@ class Node : public Raul::Stateful { public: typedef std::string ID; - Node(BeatCount duration=1/2.0, bool initial=false); + Node(TimeDuration duration, bool initial=false); Node(const Node& copy); void set_enter_action(SharedPtr action); @@ -53,8 +54,8 @@ public: SharedPtr enter_action() { return _enter_action; } SharedPtr exit_action() { return _exit_action; } - void enter(SharedPtr driver, BeatTime time); - void exit(SharedPtr driver, BeatTime time); + void enter(SharedPtr driver, TimeStamp time); + void exit(SharedPtr driver, TimeStamp time); void edges_changed(); @@ -65,15 +66,15 @@ public: void write_state(Redland::Model& model); - 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 { 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; } - bool is_selector() const { return _is_selector; } - void set_selector(bool i); + bool is_initial() const { return _is_initial; } + void set_initial(bool i) { _is_initial = i; } + bool is_active() const { return _is_active; } + TimeStamp enter_time() const { assert(_is_active); return _enter_time; } + TimeStamp exit_time() const { assert(_is_active); return _enter_time + _duration; } + TimeDuration duration() { return _duration; } + void set_duration(TimeDuration d) { _duration = d; } + bool is_selector() const { return _is_selector; } + void set_selector(bool i); inline bool changed() { return _changed; } inline void set_changed() { _changed = true; } @@ -90,8 +91,8 @@ private: bool _is_initial; bool _is_selector; bool _is_active; - BeatTime _enter_time; ///< valid iff _is_active - BeatCount _duration; + TimeStamp _enter_time; ///< valid iff _is_active + TimeDuration _duration; SharedPtr _enter_action; SharedPtr _exit_action; Edges _edges; diff --git a/src/engine/machina/Recorder.hpp b/src/engine/machina/Recorder.hpp index 7938556..5afce2a 100644 --- a/src/engine/machina/Recorder.hpp +++ b/src/engine/machina/Recorder.hpp @@ -18,10 +18,9 @@ #ifndef MACHINA_RECORDER_HPP #define MACHINA_RECORDER_HPP -#include #include #include -#include +#include #include "Machine.hpp" namespace Machina { @@ -31,9 +30,9 @@ class MachineBuilder; class Recorder : public Raul::Slave { public: - Recorder(size_t buffer_size, double tick_rate, double q); + Recorder(size_t buffer_size, TimeUnit unit, TimeStamp q); - inline void write(Raul::TickTime time, size_t size, const unsigned char* buf) { + inline void write(Raul::TimeStamp time, size_t size, const unsigned char* buf) { _record_buffer.write(time, size, buf); } @@ -42,9 +41,9 @@ public: private: virtual void _whipped(); - double _tick_rate; - Raul::StampedChunkRingBuffer _record_buffer; - SharedPtr _builder; + TimeUnit _unit; + Raul::EventRingBuffer _record_buffer; + SharedPtr _builder; }; diff --git a/src/engine/machina/SMFDriver.hpp b/src/engine/machina/SMFDriver.hpp index 55d76a0..73e8901 100644 --- a/src/engine/machina/SMFDriver.hpp +++ b/src/engine/machina/SMFDriver.hpp @@ -39,17 +39,17 @@ public: SMFDriver(SharedPtr machine = SharedPtr()); SharedPtr learn(const std::string& filename, - double q=0.0, - Raul::BeatTime max_duration=0); + Raul::TimeStamp q, + Raul::TimeDuration max_duration); SharedPtr learn(const std::string& filename, unsigned track, - double q=0.0, - Raul::BeatTime max_duration=0); + Raul::TimeStamp q, + Raul::TimeDuration max_duration); - void run(SharedPtr machine, Raul::BeatTime max_time); + void run(SharedPtr machine, Raul::TimeStamp max_time); - void write_event(Raul::BeatTime time, + void write_event(Raul::TimeStamp time, size_t ev_size, const unsigned char* ev) throw (std::logic_error) { _writer->write_event(time, ev_size, ev); } @@ -65,8 +65,8 @@ private: void learn_track(SharedPtr builder, Raul::SMFReader& reader, unsigned track, - double q, - Raul::BeatTime max_duration=0); + Raul::TimeStamp q, + Raul::TimeDuration max_duration); }; -- cgit v1.2.1