From e1a63732f796c8057751cb7f8ac98a595b91692e Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 12 Jan 2013 03:17:47 +0000 Subject: Bulk reformat. git-svn-id: http://svn.drobilla.net/lad/trunk/machina@4929 a436a847-0d15-0410-975c-d299462d15a1 --- src/client/ClientModel.cpp | 15 ++-- src/client/ClientModel.hpp | 11 ++- src/client/ClientObject.cpp | 13 ++-- src/client/ClientObject.hpp | 17 +++-- src/engine/Action.cpp | 5 +- src/engine/Action.hpp | 11 ++- src/engine/ActionFactory.cpp | 6 +- src/engine/ActionFactory.hpp | 6 +- src/engine/Controller.cpp | 48 +++++++----- src/engine/Edge.cpp | 16 ++-- src/engine/Edge.hpp | 4 +- src/engine/Engine.cpp | 23 +++--- src/engine/Evolver.cpp | 47 ++++++------ src/engine/JackDriver.cpp | 157 +++++++++++++++++++++++--------------- src/engine/JackDriver.hpp | 10 ++- src/engine/LearnRequest.cpp | 4 +- src/engine/LearnRequest.hpp | 8 +- src/engine/Loader.cpp | 72 ++++++++--------- src/engine/MIDISink.hpp | 5 +- src/engine/Machine.cpp | 128 +++++++++++++++++++------------ src/engine/MachineBuilder.cpp | 142 +++++++++++++++++++++------------- src/engine/MachineBuilder.hpp | 16 ++-- src/engine/MidiAction.cpp | 17 +++-- src/engine/MidiAction.hpp | 4 +- src/engine/Mutation.cpp | 49 +++++++----- src/engine/Node.cpp | 90 ++++++++++++---------- src/engine/Node.hpp | 18 +++-- src/engine/Problem.cpp | 136 +++++++++++++++++++-------------- src/engine/Recorder.cpp | 6 +- src/engine/Recorder.hpp | 10 ++- src/engine/SMFDriver.cpp | 49 +++++++----- src/engine/SMFDriver.hpp | 9 ++- src/engine/SMFReader.cpp | 124 +++++++++++++++++------------- src/engine/SMFReader.hpp | 34 +++++---- src/engine/SMFWriter.cpp | 53 +++++++------ src/engine/SMFWriter.hpp | 19 ++--- src/engine/Schrodinbit.hpp | 8 +- src/engine/Stateful.cpp | 3 +- src/engine/Stateful.hpp | 15 ++-- src/engine/Updates.cpp | 4 +- src/engine/jack_compat.h | 55 ------------- src/engine/machina/Context.hpp | 3 +- src/engine/machina/Controller.hpp | 27 +++++-- src/engine/machina/Driver.hpp | 24 ++++-- src/engine/machina/Engine.hpp | 3 +- src/engine/machina/Evolver.hpp | 12 ++- src/engine/machina/Loader.hpp | 3 +- src/engine/machina/Machine.hpp | 20 +++-- src/engine/machina/Mutation.hpp | 12 ++- src/engine/machina/URIs.hpp | 3 +- src/engine/machina/types.hpp | 2 +- src/engine/quantize.hpp | 6 +- src/engine/quantize_test.cpp | 8 +- src/engine/smf_test.cpp | 20 +++-- src/gui/EdgeView.cpp | 39 +++++----- src/gui/EdgeView.hpp | 3 +- src/gui/MachinaCanvas.cpp | 39 ++++++---- src/gui/MachinaCanvas.hpp | 11 ++- src/gui/MachinaGUI.cpp | 41 ++++++---- src/gui/MachinaGUI.hpp | 8 +- src/gui/NodePropertiesWindow.cpp | 31 ++++---- src/gui/NodePropertiesWindow.hpp | 13 +++- src/gui/NodeView.cpp | 12 ++- src/gui/NodeView.hpp | 3 +- src/gui/WidgetFactory.hpp | 15 ++-- src/gui/main.cpp | 15 ++-- src/machina.cpp | 23 +++--- src/midi2machina.cpp | 22 +++--- 68 files changed, 1083 insertions(+), 802 deletions(-) delete mode 100644 src/engine/jack_compat.h (limited to 'src') diff --git a/src/client/ClientModel.cpp b/src/client/ClientModel.cpp index 4af3a37..c945de7 100644 --- a/src/client/ClientModel.cpp +++ b/src/client/ClientModel.cpp @@ -24,11 +24,12 @@ SharedPtr ClientModel::find(uint64_t id) { SharedPtr key(new ClientObjectKey(id)); - Objects::iterator i = _objects.find(key); - if (i != _objects.end()) + Objects::iterator i = _objects.find(key); + if (i != _objects.end()) { return *i; - else + } else { return SharedPtr(); + } } void @@ -42,9 +43,10 @@ void ClientModel::erase_object(uint64_t id) { SharedPtr key(new ClientObjectKey(id)); - Objects::iterator i = _objects.find(key); - if (i == _objects.end()) + Objects::iterator i = _objects.find(key); + if (i == _objects.end()) { return; + } signal_erase_object.emit(*i); (*i)->set_view(SharedPtr()); @@ -55,8 +57,9 @@ void ClientModel::property(uint64_t id, URIInt key, const Raul::Atom& value) { SharedPtr object = find(id); - if (object) + if (object) { object->set(key, value); + } } } diff --git a/src/client/ClientModel.hpp b/src/client/ClientModel.hpp index de3b8ea..07500db 100644 --- a/src/client/ClientModel.hpp +++ b/src/client/ClientModel.hpp @@ -24,12 +24,15 @@ #include "ClientObject.hpp" -namespace Raul { class Atom; } +namespace Raul { +class Atom; +} namespace Machina { namespace Client { -class ClientModel { +class ClientModel +{ public: void new_object(SharedPtr object); void erase_object(uint64_t id); @@ -42,9 +45,11 @@ public: private: struct ClientObjectComparator { - inline bool operator()(SharedPtr lhs, SharedPtr rhs) const { + inline bool operator()(SharedPtr lhs, + SharedPtr rhs) const { return lhs->id() < rhs->id(); } + }; typedef std::set, ClientObjectComparator> Objects; diff --git a/src/client/ClientObject.cpp b/src/client/ClientObject.cpp index c6d254b..7f7eb9e 100644 --- a/src/client/ClientObject.cpp +++ b/src/client/ClientObject.cpp @@ -24,14 +24,12 @@ namespace Client { ClientObject::ClientObject(uint64_t id) : _id(id) -{ -} +{} ClientObject::ClientObject(const ClientObject& copy, uint64_t id) : _id(id) , _properties(copy._properties) -{ -} +{} void ClientObject::set(URIInt key, const Raul::Atom& value) @@ -43,12 +41,13 @@ ClientObject::set(URIInt key, const Raul::Atom& value) const Raul::Atom& ClientObject::get(URIInt key) const { - static const Raul::Atom null_atom; + static const Raul::Atom null_atom; Properties::const_iterator i = _properties.find(key); - if (i != _properties.end()) + if (i != _properties.end()) { return i->second; - else + } else { return null_atom; + } } } diff --git a/src/client/ClientObject.hpp b/src/client/ClientObject.hpp index 658d603..994a5ba 100644 --- a/src/client/ClientObject.hpp +++ b/src/client/ClientObject.hpp @@ -30,7 +30,8 @@ namespace Machina { namespace Client { -class ClientObject { +class ClientObject +{ public: ClientObject(uint64_t id); ClientObject(const ClientObject& copy, uint64_t id); @@ -42,7 +43,8 @@ public: sigc::signal signal_property; - class View { + class View + { public: virtual ~View() {} }; @@ -50,8 +52,8 @@ public: typedef std::map Properties; const Properties& properties() { return _properties; } - SharedPtr view() const { return _view; } - void set_view(SharedPtr view) { _view = view; } + SharedPtr view() const { return _view; } + void set_view(SharedPtr view) { _view = view; } private: uint64_t _id; @@ -60,9 +62,12 @@ private: Properties _properties; }; -class ClientObjectKey : public ClientObject { +class ClientObjectKey + : public ClientObject +{ public: - ClientObjectKey(uint64_t id) : ClientObject(id) {} + ClientObjectKey(uint64_t id) + : ClientObject(id) {} }; } diff --git a/src/engine/Action.cpp b/src/engine/Action.cpp index 59dd8c7..e49e69b 100644 --- a/src/engine/Action.cpp +++ b/src/engine/Action.cpp @@ -27,9 +27,8 @@ Action::write_state(Sord::Model& model) using namespace Raul; model.add_statement(rdf_id(model.world()), - Sord::Curie(model.world(), "rdf:type"), - Sord::Curie(model.world(), "machina:Action")); + Sord::Curie(model.world(), "rdf:type"), + Sord::Curie(model.world(), "machina:Action")); } } // namespace Machina - diff --git a/src/engine/Action.hpp b/src/engine/Action.hpp index 76834d9..f954a39 100644 --- a/src/engine/Action.hpp +++ b/src/engine/Action.hpp @@ -34,15 +34,20 @@ namespace Machina { /** An Action, executed on entering or exiting of a state. */ -struct Action : public Raul::Manageable, public Stateful { +struct Action + : public Raul::Manageable + , public Stateful { virtual void execute(MIDISink* sink, Raul::TimeStamp time) = 0; virtual void write_state(Sord::Model& model); }; -class PrintAction : public Action { +class PrintAction + : public Action +{ public: - PrintAction(const std::string& msg) : _msg(msg) {} + PrintAction(const std::string& msg) + : _msg(msg) {} void execute(MIDISink* sink, Raul::TimeStamp time) { std::cout << "t=" << time << ": " << _msg << std::endl; } diff --git a/src/engine/ActionFactory.cpp b/src/engine/ActionFactory.cpp index b6a1cc1..92bc114 100644 --- a/src/engine/ActionFactory.cpp +++ b/src/engine/ActionFactory.cpp @@ -24,10 +24,11 @@ SharedPtr ActionFactory::copy(SharedPtr copy) { SharedPtr ma = PtrCast(copy); - if (ma) + if (ma) { return SharedPtr(new MidiAction(ma->event_size(), ma->event())); - else + } else { return SharedPtr(); + } } SharedPtr @@ -53,4 +54,3 @@ ActionFactory::note_off(unsigned char note) } } // namespace Machine - diff --git a/src/engine/ActionFactory.hpp b/src/engine/ActionFactory.hpp index 0d9ce3f..1ae47c4 100644 --- a/src/engine/ActionFactory.hpp +++ b/src/engine/ActionFactory.hpp @@ -25,9 +25,9 @@ namespace Machina { struct Action; namespace ActionFactory { - SharedPtr copy(SharedPtr copy); - SharedPtr note_on(unsigned char note); - SharedPtr note_off(unsigned char note); +SharedPtr copy(SharedPtr copy); +SharedPtr note_on(unsigned char note); +SharedPtr note_off(unsigned char note); } } // namespace Machina diff --git a/src/engine/Controller.cpp b/src/engine/Controller.cpp index 7533a77..f209018 100644 --- a/src/engine/Controller.cpp +++ b/src/engine/Controller.cpp @@ -27,7 +27,8 @@ namespace Machina { -Controller::Controller(SharedPtr engine, Client::ClientModel& client_model) +Controller::Controller(SharedPtr engine, + Client::ClientModel& client_model) : _engine(engine) , _client_model(client_model) , _updates(new UpdateBuffer(4096)) @@ -39,9 +40,10 @@ uint64_t Controller::create(const Client::ClientObject& properties) { TimeDuration dur(_engine->machine()->time().unit(), - properties.get(URIs::instance().machina_duration).get_float()); + properties.get(URIs::instance().machina_duration).get_float()); SharedPtr node(new Machina::Node(dur)); - SharedPtr obj(new Client::ClientObject(properties, node->id())); + SharedPtr obj( + new Client::ClientObject(properties, node->id())); _objects.insert(node); _client_model.new_object(obj); _engine->machine()->add_node(node); @@ -55,16 +57,17 @@ Controller::announce(SharedPtr machine) for (Machina::Machine::Nodes::const_iterator n = machine->nodes().begin(); n != machine->nodes().end(); ++n) { - SharedPtr obj(new Machina::Client::ClientObject((*n)->id())); - obj->set(URIs::instance().rdf_type, - forge.make_urid(URIs::instance().machina_Node)); - obj->set(URIs::instance().machina_duration, - forge.make(float((*n)->duration().to_double()))); - obj->set(URIs::instance().machina_canvas_x, forge.make(0.0f)); - obj->set(URIs::instance().machina_canvas_y, forge.make(0.0f)); - - _objects.insert(*n); - _client_model.new_object(obj); + SharedPtr obj( + new Machina::Client::ClientObject((*n)->id())); + obj->set(URIs::instance().rdf_type, + forge.make_urid(URIs::instance().machina_Node)); + obj->set(URIs::instance().machina_duration, + forge.make(float((*n)->duration().to_double()))); + obj->set(URIs::instance().machina_canvas_x, forge.make(0.0f)); + obj->set(URIs::instance().machina_canvas_y, forge.make(0.0f)); + + _objects.insert(*n); + _client_model.new_object(obj); } for (Machina::Machine::Nodes::const_iterator n = machine->nodes().begin(); @@ -72,7 +75,8 @@ Controller::announce(SharedPtr machine) for (Machina::Node::Edges::const_iterator e = (*n)->edges().begin(); e != (*n)->edges().end(); ++e) { _objects.insert(*e); - SharedPtr eobj(new Client::ClientObject((*e)->id())); + SharedPtr eobj( + new Client::ClientObject((*e)->id())); eobj->set(URIs::instance().rdf_type, forge.make_urid(URIs::instance().rdf_type)); eobj->set(URIs::instance().machina_probability, @@ -105,12 +109,15 @@ Controller::learn(SharedPtr maid, uint64_t node_id) if (node) { _engine->machine()->learn(maid, node); } else { - std::cerr << "Failed to find node " << node_id << " for learn" << std::endl; + std::cerr << "Failed to find node " << node_id << " for learn" + << std::endl; } } void -Controller::set_property(uint64_t object_id, URIInt key, const Raul::Atom& value) +Controller::set_property(uint64_t object_id, + URIInt key, + const Raul::Atom& value) { SharedPtr object = find(object_id); if (object) { @@ -131,7 +138,8 @@ Controller::connect(uint64_t tail_id, uint64_t head_id) Raul::Forge& forge = _engine->forge(); - SharedPtr obj(new Client::ClientObject(/**this,*/ edge->id())); + SharedPtr obj( + new Client::ClientObject(edge->id())); obj->set(URIs::instance().rdf_type, forge.make_urid(URIs::instance().machina_Edge)); obj->set(URIs::instance().machina_probability, forge.make(1.0f)); @@ -185,11 +193,13 @@ Controller::process_updates() Raul::Atom value; for (uint32_t i = 0; i < read_space; ) { i += read_set(_updates, &subject, &key, &value); - SharedPtr obj = _client_model.find(subject); + SharedPtr obj = _client_model.find( + subject); if (obj) { obj->set(key, value); } else { - SharedPtr obj(new Client::ClientObject(subject)); + SharedPtr obj( + new Client::ClientObject(subject)); obj->set(key, value); _client_model.new_object(obj); } diff --git a/src/engine/Edge.cpp b/src/engine/Edge.cpp index c79d1cc..9aee198 100644 --- a/src/engine/Edge.cpp +++ b/src/engine/Edge.cpp @@ -38,9 +38,9 @@ Edge::write_state(Sord::Model& model) const Sord::Node& rdf_id = this->rdf_id(model.world()); model.add_statement( - rdf_id, - Sord::Curie(model.world(), "rdf:type"), - Sord::Curie(model.world(), "machina:Edge")); + rdf_id, + Sord::Curie(model.world(), "rdf:type"), + Sord::Curie(model.world(), "machina:Edge")); SharedPtr tail = _tail.lock(); SharedPtr head = _head; @@ -61,11 +61,11 @@ Edge::write_state(Sord::Model& model) std::cerr << "FIXME: save atom" << std::endl; /* - model.add_statement( - rdf_id, - Sord::Curie(model.world(), "machina:probability"), - AtomRDF::atom_to_node(model, Atom(_probability.get()))); - */ + model.add_statement( + rdf_id, + Sord::Curie(model.world(), "machina:probability"), + AtomRDF::atom_to_node(model, Atom(_probability.get()))); + */ } } // namespace Machina diff --git a/src/engine/Edge.hpp b/src/engine/Edge.hpp index 17afac3..10c7ab8 100644 --- a/src/engine/Edge.hpp +++ b/src/engine/Edge.hpp @@ -34,7 +34,9 @@ namespace Machina { class Node; -class Edge : public Stateful { +class Edge + : public Stateful +{ public: Edge(WeakPtr tail, SharedPtr head) : _probability(1.0f) diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 1a8c867..b103310 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -35,23 +35,23 @@ Engine::Engine(Raul::Forge& forge, , _rdf_world(rdf_world) , _loader(_forge, _rdf_world) , _forge(forge) -{ -} +{} SharedPtr Engine::new_driver(Raul::Forge& forge, const std::string& name, SharedPtr machine) { - #ifdef HAVE_JACK +#ifdef HAVE_JACK if (name == "jack") { JackDriver* driver = new JackDriver(forge, machine); driver->attach("machina"); return SharedPtr(driver); } - #endif - if (name == "smf") +#endif + if (name == "smf") { return SharedPtr(new SMFDriver(forge, machine->time().unit())); + } std::cerr << "Error: Unknown driver type `" << name << "'" << std::endl; return SharedPtr(); @@ -80,7 +80,8 @@ Engine::load_machine(const Glib::ustring& uri) * Safe to call while engine is processing. */ SharedPtr -Engine::load_machine_midi(const Glib::ustring& uri, double q, Raul::TimeDuration dur) +Engine::load_machine_midi(const Glib::ustring& uri, double q, + Raul::TimeDuration dur) { SharedPtr file_driver(new SMFDriver(_forge, dur.unit())); SharedPtr machine = file_driver->learn(uri, q, dur); @@ -111,19 +112,22 @@ void Engine::export_midi(const Glib::ustring& filename, Raul::TimeDuration dur) { SharedPtr machine = _driver->machine(); - SharedPtr file_driver(new Machina::SMFDriver(_forge, dur.unit())); + SharedPtr file_driver( + new Machina::SMFDriver(_forge, dur.unit())); const bool activated = _driver->is_activated(); - if (activated) + if (activated) { _driver->deactivate(); // FIXME: disable instead + } file_driver->writer()->start(filename, TimeStamp(dur.unit(), 0.0)); file_driver->run(machine, dur); machine->reset(NULL, machine->time()); file_driver->writer()->finish(); - if (activated) + if (activated) { _driver->activate(); + } } void @@ -139,4 +143,3 @@ Engine::set_quantization(double q) } } // namespace Machina - diff --git a/src/engine/Evolver.cpp b/src/engine/Evolver.cpp index 83b0d75..a71d64b 100644 --- a/src/engine/Evolver.cpp +++ b/src/engine/Evolver.cpp @@ -32,40 +32,42 @@ using namespace boost; namespace Machina { -Evolver::Evolver(TimeUnit unit, const string& target_midi, SharedPtr seed) +Evolver::Evolver(TimeUnit unit, const string& target_midi, + SharedPtr seed) : _problem(new Problem(unit, target_midi, seed)) , _seed_fitness(-FLT_MAX) { SharedPtr > m(new HybridMutation()); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::Compress())); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::AddNode())); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::Compress())); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::AddNode())); //m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( // new Mutation::RemoveNode())); //m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( // new Mutation::AdjustNode())); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::SwapNodes())); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::AddEdge())); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::RemoveEdge())); - m->append_mutation(1/6.0f, boost::shared_ptr< Eugene::Mutation >( - new Mutation::AdjustEdge())); - - boost::shared_ptr< Selection > s(new TournamentSelection(_problem, 3, 0.8)); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::SwapNodes())); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::AddEdge())); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::RemoveEdge())); + m->append_mutation(1 / 6.0f, boost::shared_ptr< Eugene::Mutation >( + new Mutation::AdjustEdge())); + + boost::shared_ptr< Selection > s(new TournamentSelection( + _problem, 3, 0.8)); boost::shared_ptr< Crossover > crossover; _ga = SharedPtr(new MachinaGA(_problem, s, crossover, m, - 20, 20, 2, 1.0, 0.0)); + 20, 20, 2, 1.0, 0.0)); } void Evolver::seed(SharedPtr parent) { /*_best = SharedPtr(new Machine(*parent.get())); - _best_fitness = _problem->fitness(*_best.get());*/ + _best_fitness = _problem->fitness(*_best.get());*/ _problem->seed(parent); _seed_fitness = _problem->fitness(*parent.get()); } @@ -87,15 +89,15 @@ Evolver::_run() float new_best = _ga->best_fitness(); /*cout << _problem->fitness_less(old_best, *_ga->best().get()) << endl; - cout << "best: " << _ga->best().get() << endl; - cout << "best fitness: " << _problem->fitness(*_ga->best().get()) << endl; - cout << "old best: " << old_best << endl; - cout << "new best: " << new_best << endl;*/ + cout << "best: " << _ga->best().get() << endl; + cout << "best fitness: " << _problem->fitness(*_ga->best().get()) << endl; + cout << "old best: " << old_best << endl; + cout << "new best: " << new_best << endl;*/ cout << "generation best: " << new_best << endl; if (_problem->fitness_less_than(old_best, new_best)) { _improvement = true; - old_best = new_best; + old_best = new_best; cout << "*** NEW BEST: " << new_best << endl; } @@ -104,4 +106,3 @@ Evolver::_run() } } // namespace Machina - diff --git a/src/engine/JackDriver.cpp b/src/engine/JackDriver.cpp index f863bae..5319d53 100644 --- a/src/engine/JackDriver.cpp +++ b/src/engine/JackDriver.cpp @@ -26,7 +26,6 @@ #include "JackDriver.hpp" #include "LearnRequest.hpp" #include "MidiAction.hpp" -#include "jack_compat.h" using namespace Machina; using namespace std; @@ -46,8 +45,9 @@ JackDriver::JackDriver(Raul::Forge& forge, SharedPtr machine) , _quantization(0.0f) , _stop(0) , _stop_flag(false) - , _record_dur(_frames_unit) // = 0 - , _recording(false) + , _record_dur(_frames_unit) + , // = 0 + _recording(false) , _is_activated(false) { _context.set_sink(this); @@ -62,8 +62,9 @@ void JackDriver::attach(const std::string& client_name) { // Already connected - if (_client) + if (_client) { return; + } jack_set_error_function(jack_error_cb); @@ -81,25 +82,35 @@ JackDriver::attach(const std::string& client_name) _context.time().set_tick_rate(sample_rate()); - _input_port = jack_port_register(jack_client(), - "in", - JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, - 0); + _input_port = jack_port_register( + jack_client(), + "in", + JACK_DEFAULT_MIDI_TYPE, + JackPortIsInput, + 0); - if (!_input_port) - std:: cerr << "WARNING: Failed to create MIDI input port." << std::endl; + if (!_input_port) { + std::cerr << "WARNING: Failed to create MIDI input port." + << std::endl; + } - _output_port = jack_port_register(jack_client(), - "out", - JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, - 0); + _output_port = jack_port_register( + jack_client(), + "out", + JACK_DEFAULT_MIDI_TYPE, + JackPortIsOutput, + 0); - if (!_output_port) - std::cerr << "WARNING: Failed to create MIDI output port." << std::endl; + if (!_output_port) { + std::cerr << "WARNING: Failed to create MIDI output port." + << std::endl; + } - if (!_machine) + if (!_machine) { _machine = SharedPtr( - new Machine(TimeUnit::frames(jack_get_sample_rate(jack_client())))); + new Machine(TimeUnit::frames(jack_get_sample_rate( + jack_client())))); + } _machine->activate(); } @@ -123,7 +134,7 @@ JackDriver::detach() if (_client) { deactivate(); jack_client_close(_client); - _client = NULL; + _client = NULL; _is_activated = false; } } @@ -141,8 +152,9 @@ JackDriver::activate() void JackDriver::deactivate() { - if (_client) + if (_client) { jack_deactivate(_client); + } _is_activated = false; } @@ -150,21 +162,24 @@ JackDriver::deactivate() void JackDriver::set_machine(SharedPtr machine) { - if (machine == _machine) + if (machine == _machine) { return; + } SharedPtr last_machine = _last_machine; // Keep a reference _machine_changed.reset(0); assert(!last_machine.unique()); _machine = machine; - if (is_activated()) + if (is_activated()) { _machine_changed.wait(); + } assert(_machine == machine); last_machine.reset(); } void -JackDriver::process_input(SharedPtr machine, const Raul::TimeSlice& time) +JackDriver::process_input(SharedPtr machine, + const Raul::TimeSlice& time) { // We only actually read Jack input at the beginning of a cycle //assert(time.offset_ticks().is_zero()); @@ -173,30 +188,37 @@ JackDriver::process_input(SharedPtr machine, const Raul::TimeSlice& tim if (_recording) { 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); + void* jack_buffer = jack_port_get_buffer(_input_port, + nframes); + const jack_nframes_t event_count = jack_midi_get_event_count( + jack_buffer); - for (jack_nframes_t i=0; i < event_count; ++i) { + for (jack_nframes_t i = 0; i < event_count; ++i) { jack_midi_event_t ev; jack_midi_event_get(&ev, jack_buffer, i); const TimeStamp rel_time_frames = TimeStamp(_frames_unit, ev.time); const TimeStamp time_frames = _record_dur + rel_time_frames; - _recorder->write(time.ticks_to_beats(time_frames), ev.size, ev.buffer); + _recorder->write(time.ticks_to_beats( + time_frames), ev.size, ev.buffer); } - if (event_count > 0) + if (event_count > 0) { _recorder->whip(); + } _record_dur += time.length_ticks(); } else { - 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); + const jack_nframes_t nframes = time.length_ticks().ticks(); + + void* jack_buffer = jack_port_get_buffer(_input_port,nframes); - for (jack_nframes_t i=0; i < event_count; ++i) { + const jack_nframes_t event_count = jack_midi_get_event_count( + jack_buffer); + + for (jack_nframes_t i = 0; i < event_count; ++i) { jack_midi_event_t ev; jack_midi_event_get(&ev, jack_buffer, i); @@ -207,7 +229,8 @@ JackDriver::process_input(SharedPtr machine, const Raul::TimeSlice& tim learn->enter_action()->set_event(ev.size, ev.buffer); learn->start(_quantization.get(), TimeStamp(TimeUnit::frames(sample_rate()), - jack_last_frame_time(_client) + ev.time, 0)); + jack_last_frame_time(_client) + + ev.time, 0)); } } else if (ev.buffer[0] == 0x80) { @@ -218,13 +241,15 @@ JackDriver::process_input(SharedPtr machine, const Raul::TimeSlice& tim if (learn->started()) { learn->exit_action()->set_event(ev.size, ev.buffer); learn->finish( - TimeStamp(TimeUnit::frames(sample_rate()), - jack_last_frame_time(_client) + ev.time, 0)); + TimeStamp(TimeUnit::frames(sample_rate()), + jack_last_frame_time(_client) + ev.time, + 0)); const uint64_t id = Stateful::next_id(); write_set(_updates, id, URIs::instance().rdf_type, - _forge.make_urid(URIs::instance().machina_MidiAction)); + _forge.make_urid(URIs::instance(). + machina_MidiAction)); write_set(_updates, learn->node()->id(), URIs::instance().machina_enter_action, _forge.make((int32_t)id)); @@ -246,44 +271,49 @@ JackDriver::write_event(Raul::TimeStamp time, size_t size, const byte* event) { - if (!_output_port) + if (!_output_port) { return; + } const Raul::TimeSlice& slice = _context.time(); - if (slice.beats_to_ticks(time) + slice.offset_ticks() < slice.start_ticks()) { + if (slice.beats_to_ticks(time) + slice.offset_ticks() < + slice.start_ticks()) { std::cerr << "ERROR: Missed event by " << slice.start_ticks() - - (slice.beats_to_ticks(time) + slice.offset_ticks()) + - (slice.beats_to_ticks(time) + slice.offset_ticks()) << " ticks" << "\n\tbpm: " << slice.bpm() << "\n\tev time: " << slice.beats_to_ticks(time) << "\n\tcycle_start: " << slice.start_ticks() - << "\n\tcycle_end: " << slice.start_ticks() + slice.length_ticks() - << "\n\tcycle_length: " << slice.length_ticks() << std::endl << std::endl; + << "\n\tcycle_end: " << slice.start_ticks() + + slice.length_ticks() + << "\n\tcycle_length: " << slice.length_ticks() + << std::endl << std::endl; return; } const TimeDuration nframes = slice.length_ticks(); const TimeStamp offset = slice.beats_to_ticks(time) - + slice.offset_ticks() - slice.start_ticks(); + + slice.offset_ticks() - slice.start_ticks(); - if ( ! (offset < slice.offset_ticks() + nframes)) { + if (!(offset < slice.offset_ticks() + nframes)) { std::cerr << "ERROR: Event offset " << offset << " outside cycle " << "\n\tbpm: " << slice.bpm() << "\n\tev time: " << slice.beats_to_ticks(time) << "\n\tcycle_start: " << slice.start_ticks() - << "\n\tcycle_end: " << slice.start_ticks() + slice.length_ticks() + << "\n\tcycle_end: " << slice.start_ticks() + + slice.length_ticks() << "\n\tcycle_length: " << slice.length_ticks() << std::endl; } else { #ifdef JACK_MIDI_NEEDS_NFRAMES jack_midi_event_write( - jack_port_get_buffer(_output_port, nframes), offset, - event, size, nframes); + jack_port_get_buffer(_output_port, nframes), offset, + event, size, nframes); #else jack_midi_event_write( - jack_port_get_buffer(_output_port, nframes.ticks()), offset.ticks(), - event, size); + jack_port_get_buffer(_output_port, nframes.ticks()), offset.ticks(), + event, size); #endif } } @@ -313,9 +343,9 @@ JackDriver::on_process(jack_nframes_t nframes) // Machine was switched since last cycle, finalize old machine. if (machine != _last_machine) { if (_last_machine) { - assert(!_last_machine.unique()); // Realtime, can't delete + assert(!_last_machine.unique()); // Realtime, can't delete _last_machine->reset(_context.sink(), _last_machine->time()); // Exit all active states - _last_machine.reset(); // Cut our reference + _last_machine.reset(); // Cut our reference } _machine_changed.post(); // Signal we're done with it } @@ -325,13 +355,15 @@ JackDriver::on_process(jack_nframes_t nframes) return; } - if (_stop_flag) + if (_stop_flag) { machine->reset(_context.sink(), _context.time().start_beats()); + } process_input(machine, _context.time()); - if (machine->is_empty() || !machine->is_activated()) + if (machine->is_empty() || !machine->is_activated()) { goto end; + } while (true) { const uint32_t run_dur_frames = machine->run(_context, _updates); @@ -348,14 +380,16 @@ JackDriver::on_process(jack_nframes_t nframes) machine->reset(_context.sink(), machine->time()); _context.time().set_slice(TimeStamp(_frames_unit, 0, 0), - TimeStamp(_frames_unit, nframes - run_dur_frames, 0)); - _context.time().set_offset(TimeStamp(_frames_unit, run_dur_frames, 0)); + TimeStamp(_frames_unit, nframes + - run_dur_frames, 0)); + _context.time().set_offset(TimeStamp(_frames_unit, run_dur_frames, + 0)); } else { // Machine ran for entire cycle _context.time().set_slice( - _context.time().start_ticks() + _context.time().length_ticks(), - TimeStamp(_frames_unit, 0, 0)); + _context.time().start_ticks() + _context.time().length_ticks(), + TimeStamp(_frames_unit, 0, 0)); break; } } @@ -375,10 +409,11 @@ end: void JackDriver::stop() { - if (recording()) + if (recording()) { finish_record(); + } - _stop_flag= true; + _stop_flag = true; _stop.wait(); _machine->deactivate(); } @@ -387,10 +422,12 @@ void JackDriver::start_record(bool step) { // FIXME: Choose an appropriate maximum ringbuffer size - _recorder = SharedPtr(new Recorder(_forge, 1024, _beats_unit, _quantization.get(), step)); + _recorder + = SharedPtr(new Recorder(_forge, 1024, _beats_unit, + _quantization.get(), step)); _recorder->start(); _record_dur = 0; - _recording = true; + _recording = true; } void diff --git a/src/engine/JackDriver.hpp b/src/engine/JackDriver.hpp index 9f47363..8b62424 100644 --- a/src/engine/JackDriver.hpp +++ b/src/engine/JackDriver.hpp @@ -43,7 +43,9 @@ class Node; * "Ticks" are individual frames when running under this driver, and all code * in the processing context must be realtime safe (non-blocking). */ -class JackDriver : public Machina::Driver { +class JackDriver + : public Machina::Driver +{ public: JackDriver(Raul::Forge& forge, SharedPtr machine = SharedPtr()); @@ -81,7 +83,7 @@ public: } bool is_activated() const { return _is_activated; } - bool is_attached() const { return (_client != NULL); } + bool is_attached() const { return _client != NULL; } bool is_realtime() const { return _client && jack_is_realtime(_client); } jack_nframes_t sample_rate() const { return jack_get_sample_rate(_client); } @@ -107,8 +109,8 @@ private: Context _context; - Raul::TimeUnit _frames_unit; - Raul::TimeUnit _beats_unit; + Raul::TimeUnit _frames_unit; + Raul::TimeUnit _beats_unit; Raul::DoubleBuffer _bpm; Raul::DoubleBuffer _quantization; diff --git a/src/engine/LearnRequest.cpp b/src/engine/LearnRequest.cpp index ae77e7b..eabf568 100644 --- a/src/engine/LearnRequest.cpp +++ b/src/engine/LearnRequest.cpp @@ -43,8 +43,8 @@ LearnRequest::create(SharedPtr maid, SharedPtr node) void LearnRequest::start(double q, Raul::TimeStamp time) { - _started = true; - _start_time = time; + _started = true; + _start_time = time; _quantization = q; } diff --git a/src/engine/LearnRequest.hpp b/src/engine/LearnRequest.hpp index 8a5f1e0..af28017 100644 --- a/src/engine/LearnRequest.hpp +++ b/src/engine/LearnRequest.hpp @@ -34,10 +34,12 @@ class MidiAction; /** A request to MIDI learn a certain node. */ -class LearnRequest : public Raul::Manageable { +class LearnRequest + : public Raul::Manageable +{ public: - static SharedPtr - create(SharedPtr maid, SharedPtr node); + static SharedPtrcreate(SharedPtr maid, + SharedPtr node); void start(double q, Raul::TimeStamp time); void finish(TimeStamp time); diff --git a/src/engine/Loader.cpp b/src/engine/Loader.cpp index 1ce8fae..1a85e29 100644 --- a/src/engine/Loader.cpp +++ b/src/engine/Loader.cpp @@ -69,27 +69,27 @@ Loader::load(const Glib::ustring& uri) cout << "[Loader] Loading " << document_uri << endl; machine = SharedPtr( - new Machine(TimeUnit::beats(MACHINA_PPQN))); + new Machine(TimeUnit::beats(MACHINA_PPQN))); typedef std::map > Created; Created created; Sord::Model model(_rdf_world, document_uri); - SerdEnv* env = serd_env_new(NULL); + SerdEnv* env = serd_env_new(NULL); model.load_file(env, SERD_TURTLE, document_uri); serd_env_free(env); Sord::Node nil; - Sord::URI rdf_type(_rdf_world, NS_RDF "type"); + Sord::URI rdf_type(_rdf_world, NS_RDF "type"); Sord::URI machina_SelectorNode(_rdf_world, NS_MACHINA "initialNode"); - Sord::URI machina_node(_rdf_world, NS_MACHINA "node"); - Sord::URI machina_initialNode(_rdf_world, NS_MACHINA "initialNode"); - Sord::URI machina_duration(_rdf_world, NS_MACHINA "duration"); - Sord::URI machina_edge(_rdf_world, NS_MACHINA "edge"); - Sord::URI machina_tail(_rdf_world, NS_MACHINA "tail"); - Sord::URI machina_head(_rdf_world, NS_MACHINA "head"); - Sord::URI machina_probability(_rdf_world, NS_MACHINA "probability"); + Sord::URI machina_node(_rdf_world, NS_MACHINA "node"); + Sord::URI machina_initialNode(_rdf_world, NS_MACHINA "initialNode"); + Sord::URI machina_duration(_rdf_world, NS_MACHINA "duration"); + Sord::URI machina_edge(_rdf_world, NS_MACHINA "edge"); + Sord::URI machina_tail(_rdf_world, NS_MACHINA "tail"); + Sord::URI machina_head(_rdf_world, NS_MACHINA "head"); + Sord::URI machina_probability(_rdf_world, NS_MACHINA "probability"); Sord::Node machine_node = Sord::URI(_rdf_world, "."); @@ -97,12 +97,12 @@ Loader::load(const Glib::ustring& uri) for (Sord::Iter i = model.find(machine_node, machina_initialNode, nil); !i.end(); ++i) { const Sord::Node& node_id = i.get_object(); - Sord::Iter d = model.find(node_id, machina_duration, nil); - SharedPtr node( + Sord::Iter d = model.find(node_id, machina_duration, nil); + SharedPtr node( new Node( - TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), - d.get_object().to_float()), - true)); + TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), + d.get_object().to_float()), + true)); Sord::Iter s = model.find(node_id, rdf_type, machina_SelectorNode); if (!s.end()) { @@ -117,12 +117,12 @@ Loader::load(const Glib::ustring& uri) for (Sord::Iter i = model.find(machine_node, machina_node, nil); !i.end(); ++i) { const Sord::Node& node_id = i.get_object(); - Sord::Iter d = model.find(node_id, machina_duration, nil); + Sord::Iter d = model.find(node_id, machina_duration, nil); if (created.find(node_id) == created.end()) { SharedPtr node(new Node( - TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), - d.get_object().to_float()), - false)); + TimeStamp(TimeUnit(TimeUnit::BEATS, MACHINA_PPQN), + d.get_object().to_float()), + false)); machine->add_node(node); created[node_id] = node; } @@ -133,25 +133,30 @@ Loader::load(const Glib::ustring& uri) /* Get note actions */ query = Query(_rdf_world, ustring( - "SELECT DISTINCT ?node ?note WHERE {\n" - " ?node :enterAction [ a :MidiAction; :midiNote ?note ] ;\n" - " :exitAction [ a :MidiAction; :midiNote ?note ] .\n" - "}\n")); + "SELECT DISTINCT ?node ?note WHERE {\n" + " ?node :enterAction [ a :MidiAction; :midiNote ?note ] ;\n" + " :exitAction [ a :MidiAction; :midiNote ?note ] .\n" + "}\n")); results = query.run(_rdf_world, model); for (; !results->finished(); results->next()) { - Created::iterator node_i = created.find((const char*)results->get("node")); + Created::iterator node_i + = created.find((const char*)results->get("node")); if (node_i != created.end()) { - SharedPtr node = node_i->second; - const int note_num = results->get("note").to_int(); + SharedPtr node = node_i->second; + const int note_num = results->get("note").to_int(); if (note_num >= 0 && note_num <= 127) { - node->set_enter_action(ActionFactory::note_on((unsigned char)note_num)); - node->set_exit_action(ActionFactory::note_off((unsigned char)note_num)); + node->set_enter_action( + ActionFactory::note_on((uint8_t)note_num)); + node->set_exit_action( + ActionFactory::note_off((uint8_t)note_num)); } else { - cerr << "WARNING: MIDI note number out of range, ignoring." << endl; + cerr << "WARNING: MIDI note number out of range, ignoring." + << endl; } } else { - cerr << "WARNING: Found note for unknown states. Ignoring." << endl; + cerr << "WARNING: Found note for unknown states. Ignoring." + << endl; } } #endif @@ -173,7 +178,7 @@ Loader::load(const Glib::ustring& uri) Created::iterator tail_i = created.find(tail); Created::iterator head_i = created.find(head); - if (tail_i != created.end() && head_i != created.end()) { + if (( tail_i != created.end()) && ( head_i != created.end()) ) { const SharedPtr tail = tail_i->second; const SharedPtr head = head_i->second; @@ -183,12 +188,12 @@ Loader::load(const Glib::ustring& uri) } else { cerr << "[Loader] WARNING: Ignored edge between unknown nodes " - << tail << " -> " << head << endl; + << tail << " -> " << head << endl; } } - if (machine && machine->nodes().size() > 0) { + if (machine && ( machine->nodes().size() > 0) ) { machine->reset(NULL, machine->time()); return machine; } else { @@ -197,4 +202,3 @@ Loader::load(const Glib::ustring& uri) } } // namespace Machina - diff --git a/src/engine/MIDISink.hpp b/src/engine/MIDISink.hpp index 47aa234..1bf53dc 100644 --- a/src/engine/MIDISink.hpp +++ b/src/engine/MIDISink.hpp @@ -24,7 +24,9 @@ namespace Machina { /** Pure virtual base for anything you can write MIDI to. */ -class MIDISink : public Raul::Deletable { +class MIDISink + : public Raul::Deletable +{ public: virtual void write_event(Raul::TimeStamp time, size_t ev_size, @@ -34,4 +36,3 @@ public: } // namespace Machina #endif // MACHINA_MIDI_SINK_HPP - diff --git a/src/engine/Machine.cpp b/src/engine/Machine.cpp index 8a7f0b4..92a0d7e 100644 --- a/src/engine/Machine.cpp +++ b/src/engine/Machine.cpp @@ -43,8 +43,7 @@ Machine::Machine(TimeUnit unit) , _time(unit, 0, 0) , _is_activated(false) , _is_finished(false) -{ -} +{} /** Copy a Machine. * @@ -60,14 +59,16 @@ Machine::Machine(const Machine& copy) { std::map< SharedPtr, SharedPtr > replacements; - for (Nodes::const_iterator n = copy._nodes.begin(); n != copy._nodes.end(); ++n) { + for (Nodes::const_iterator n = copy._nodes.begin(); n != copy._nodes.end(); + ++n) { SharedPtr node(new Machina::Node(*n->get())); _nodes.push_back(node); replacements[*n] = node; } for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { - for (Node::Edges::const_iterator e = (*n)->edges().begin(); e != (*n)->edges().end(); ++e) { + for (Node::Edges::const_iterator e = (*n)->edges().begin(); + e != (*n)->edges().end(); ++e) { (*e)->set_tail(*n); (*e)->set_head(replacements[(*e)->head()]); assert((*e)->head()); @@ -78,23 +79,26 @@ Machine::Machine(const Machine& copy) Machine& Machine::operator=(const Machine& other) { - _active_nodes = std::vector< SharedPtr >(MAX_ACTIVE_NODES, SharedPtr()); - _is_activated = false; - _is_finished = false; - _time = other._time; + _active_nodes = std::vector< SharedPtr >(MAX_ACTIVE_NODES, + SharedPtr()); + _is_activated = false; + _is_finished = false; + _time = other._time; _pending_learn = SharedPtr(); _nodes.clear(); map< SharedPtr, SharedPtr > replacements; - for (Nodes::const_iterator n = other._nodes.begin(); n != other._nodes.end(); ++n) { + for (Nodes::const_iterator n = other._nodes.begin(); n != other._nodes.end(); + ++n) { SharedPtr node(new Machina::Node(*n->get())); _nodes.push_back(node); replacements[*n] = node; } for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { - for (Node::Edges::const_iterator e = (*n)->edges().begin(); e != (*n)->edges().end(); ++e) { + for (Node::Edges::const_iterator e = (*n)->edges().begin(); + e != (*n)->edges().end(); ++e) { (*e)->set_tail(*n); (*e)->set_head(replacements[(*e)->head()]); assert((*e)->head()); @@ -108,15 +112,19 @@ Machine::operator=(const Machine& other) SharedPtr Machine::random_node() { - if (_nodes.empty()) + if (_nodes.empty()) { return SharedPtr(); + } size_t i = rand() % _nodes.size(); // FIXME: O(n) worst case :( - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n, --i) - if (i == 0) + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n, + --i) { + if (i == 0) { return *n; + } + } return SharedPtr(); } @@ -127,8 +135,9 @@ Machine::random_edge() { SharedPtr tail = random_node(); - for (size_t i = 0; i < _nodes.size() && tail->edges().empty(); ++i) + for (size_t i = 0; i < _nodes.size() && tail->edges().empty(); ++i) { tail = random_node(); + } return tail ? tail->random_edge() : SharedPtr(); } @@ -145,8 +154,9 @@ Machine::remove_node(SharedPtr node) { _nodes.erase(std::find(_nodes.begin(), _nodes.end(), node)); - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { (*n)->remove_edge_to(node); + } } /** Exit all active states and reset time to 0. @@ -155,20 +165,23 @@ void Machine::reset(MIDISink* sink, Raul::TimeStamp time) { if (!_is_finished) { - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); + ++n) { SharedPtr node = (*n); - if (sink && node->is_active()) + if (sink && node->is_active()) { node->exit(sink, time); + } assert(!node->is_active()); } - for (size_t i=0; i < MAX_ACTIVE_NODES; ++i) + for (size_t i = 0; i < MAX_ACTIVE_NODES; ++i) { _active_nodes.at(i).reset(); + } } - _time = TimeStamp(_time.unit(), 0, 0); + _time = TimeStamp(_time.unit(), 0, 0); _is_finished = false; } @@ -179,12 +192,12 @@ Machine::earliest_node() const { SharedPtr earliest; - for (size_t i=0; i < MAX_ACTIVE_NODES; ++i) { + for (size_t i = 0; i < MAX_ACTIVE_NODES; ++i) { SharedPtr node = _active_nodes.at(i); if (node) { assert(node->is_active()); - if (!earliest || node->exit_time() < earliest->exit_time()) { + if (!earliest || ( node->exit_time() < earliest->exit_time()) ) { earliest = node; } } @@ -198,14 +211,16 @@ Machine::earliest_node() const * Returns true if node was entered, or false if the maximum active nodes has been reached. */ bool -Machine::enter_node(Context& context, SharedPtr node, SharedPtr updates) +Machine::enter_node(Context& context, + SharedPtr node, + SharedPtr updates) { assert(!node->is_active()); /* FIXME: Would be best to use the MIDI note here as a hash key, at least * while all actions are still MIDI notes... */ size_t index = (rand() % MAX_ACTIVE_NODES); - for (size_t i=0; i < MAX_ACTIVE_NODES; ++i) { + for (size_t i = 0; i < MAX_ACTIVE_NODES; ++i) { if (_active_nodes.at(index) == NULL) { node->enter(context.sink(), _time); assert(node->is_active()); @@ -227,7 +242,9 @@ Machine::enter_node(Context& context, SharedPtr node, SharedPtr node, SharedPtr updates) +Machine::exit_node(Context& context, + SharedPtr node, + SharedPtr updates) { node->exit(context.sink(), _time); write_set(updates, @@ -237,9 +254,11 @@ Machine::exit_node(Context& context, SharedPtr node, SharedPtris_active()); - for (size_t i=0; i < MAX_ACTIVE_NODES; ++i) - if (_active_nodes.at(i) == node) + for (size_t i = 0; i < MAX_ACTIVE_NODES; ++i) { + if (_active_nodes.at(i) == node) { _active_nodes.at(i).reset(); + } + } // Activate successors to this node // (that aren't aready active right now) @@ -247,14 +266,14 @@ Machine::exit_node(Context& context, SharedPtr node, SharedPtris_selector()) { const double rand_normal = rand() / (double)RAND_MAX; // [0, 1] - double range_min = 0; + double range_min = 0; for (Node::Edges::const_iterator s = node->edges().begin(); - s != node->edges().end(); ++s) { + s != node->edges().end(); ++s) { if (!(*s)->head()->is_active() - && rand_normal > range_min - && rand_normal < range_min + (*s)->probability()) { + && ( rand_normal > range_min) + && ( rand_normal < range_min + (*s)->probability()) ) { enter_node(context, (*s)->head(), updates); break; @@ -267,15 +286,16 @@ Machine::exit_node(Context& context, SharedPtr node, SharedPtredges().begin(); - e != node->edges().end(); ++e) { + e != node->edges().end(); ++e) { const double rand_normal = rand() / (double)RAND_MAX; // [0, 1] if (rand_normal <= (*e)->probability()) { SharedPtr head = (*e)->head(); - if ( ! head->is_active()) + if (!head->is_active()) { enter_node(context, head, updates); + } } } @@ -294,19 +314,23 @@ Machine::exit_node(Context& context, SharedPtr node, SharedPtr updates) { - if (_is_finished) + if (_is_finished) { return 0; + } - const TimeStamp cycle_end_frames = context.time().start_ticks() + context.time().length_ticks(); - const TimeStamp cycle_end = context.time().ticks_to_beats(cycle_end_frames); + const TimeStamp cycle_end_frames = context.time().start_ticks() + + context.time().length_ticks(); + const TimeStamp cycle_end = context.time().ticks_to_beats( + cycle_end_frames); assert(_is_activated); // Initial run, enter all initial states if (_time.is_zero()) { bool entered = false; - if ( ! _nodes.empty()) { - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { + if (!_nodes.empty()) { + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); + ++n) { if ((*n)->is_active()) { (*n)->exit(context.sink(), _time); write_set(updates, @@ -316,8 +340,9 @@ Machine::run(Context& context, SharedPtr updates) } if ((*n)->is_initial()) { - if (enter_node(context, (*n), updates)) + if (enter_node(context, (*n), updates)) { entered = true; + } } } } @@ -334,13 +359,16 @@ Machine::run(Context& context, SharedPtr updates) if (!earliest) { // No more active states, machine is finished #ifndef NDEBUG - for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) - assert( ! (*n)->is_active()); + for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); + ++n) { + assert(!(*n)->is_active()); + } #endif _is_finished = true; break; - } else if (context.time().beats_to_ticks(earliest->exit_time()) < cycle_end_frames) { + } else if (context.time().beats_to_ticks(earliest->exit_time()) < + cycle_end_frames) { // Earliest active state ends this cycle _time = earliest->exit_time(); exit_node(context, earliest, updates); @@ -375,8 +403,8 @@ Machine::write_state(Sord::Model& model) model.world().add_prefix("machina", "http://drobilla.net/ns/machina#"); model.add_statement(model.base_uri(), - Sord::Curie(model.world(), "rdf:type"), - Sord::Curie(model.world(), "machina:Machine")); + Sord::Curie(model.world(), "rdf:type"), + Sord::Curie(model.world(), "machina:Machine")); for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { @@ -384,25 +412,25 @@ Machine::write_state(Sord::Model& model) if ((*n)->is_initial()) { model.add_statement(model.base_uri(), - Sord::Curie(model.world(), "machina:initialNode"), - (*n)->rdf_id(model.world())); + Sord::Curie(model.world(), "machina:initialNode"), + (*n)->rdf_id(model.world())); } else { model.add_statement(model.base_uri(), - Sord::Curie(model.world(), "machina:node"), - (*n)->rdf_id(model.world())); + Sord::Curie(model.world(), "machina:node"), + (*n)->rdf_id(model.world())); } } for (Nodes::const_iterator n = _nodes.begin(); n != _nodes.end(); ++n) { for (Node::Edges::const_iterator e = (*n)->edges().begin(); - e != (*n)->edges().end(); ++e) { + e != (*n)->edges().end(); ++e) { (*e)->write_state(model); model.add_statement(model.base_uri(), - Sord::Curie(model.world(), "machina:edge"), - (*e)->rdf_id(model.world())); + Sord::Curie(model.world(), "machina:edge"), + (*e)->rdf_id(model.world())); } } diff --git a/src/engine/MachineBuilder.cpp b/src/engine/MachineBuilder.cpp index 1eaf22e..818c893 100644 --- a/src/engine/MachineBuilder.cpp +++ b/src/engine/MachineBuilder.cpp @@ -42,15 +42,14 @@ MachineBuilder::MachineBuilder(SharedPtr machine, double q, bool step) , _connect_node(_initial_node) , _connect_node_end_time(_time) // = 0 , _step(step) -{ -} +{} void MachineBuilder::reset() { - _time = TimeStamp(_machine->time().unit()); // = 0 - _initial_node = SharedPtr(new Node(_time, true)); // duration 0 - _connect_node = _initial_node; + _time = TimeStamp(_machine->time().unit()); // = 0 + _initial_node = SharedPtr(new Node(_time, true)); // duration 0 + _connect_node = _initial_node; _connect_node_end_time = _time; // = 0 } @@ -63,7 +62,8 @@ MachineBuilder::is_delay_node(SharedPtr node) const /** Set the duration of a node, with quantization. */ void -MachineBuilder::set_node_duration(SharedPtr node, Raul::TimeDuration d) const +MachineBuilder::set_node_duration(SharedPtr node, + Raul::TimeDuration d) const { if (_step) { node->set_duration(TimeStamp(d.unit(), 1, 0)); @@ -73,9 +73,9 @@ MachineBuilder::set_node_duration(SharedPtr node, Raul::TimeDuration d) co Raul::TimeStamp q_dur = quantize(TimeStamp(d.unit(), _quantization), d); // Never quantize a note to duration 0 - if (q_dur.is_zero() && ( 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); } @@ -85,8 +85,10 @@ MachineBuilder::set_node_duration(SharedPtr node, Raul::TimeDuration d) co */ SharedPtr MachineBuilder::connect_nodes(SharedPtr m, - SharedPtr tail, Raul::TimeStamp tail_end_time, - SharedPtr head, Raul::TimeStamp 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); @@ -95,7 +97,8 @@ MachineBuilder::connect_nodes(SharedPtr m, if (is_delay_node(tail) && tail->edges().size() == 0) { // Tail is a delay node, just accumulate the time difference into it - set_node_duration(tail, tail->duration() + head_start_time - tail_end_time); + set_node_duration(tail, + tail->duration() + head_start_time - tail_end_time); tail->add_edge(SharedPtr(new Edge(tail, head))); } else if (_step || (head_start_time == tail_end_time)) { // Connect directly @@ -117,10 +120,11 @@ MachineBuilder::event(Raul::TimeStamp time_offset, unsigned char* buf) { const Raul::TimeUnit unit = time_offset.unit(); - Raul::TimeStamp t = _time + time_offset; + Raul::TimeStamp t = _time + time_offset; - if (ev_size == 0) + if (ev_size == 0) { return; + } if ((buf[0] & 0xF0) == LV2_MIDI_MSG_NOTE_ON) { @@ -132,10 +136,11 @@ MachineBuilder::event(Raul::TimeStamp time_offset, // If currently polyphonic, use a poly node with no successors as connect node // Results in patterns closest to what a human would choose - if ( ! _poly_nodes.empty()) { - for (PolyList::iterator j = _poly_nodes.begin(); j != _poly_nodes.end(); ++j) { + if (!_poly_nodes.empty()) { + for (PolyList::iterator j = _poly_nodes.begin(); + j != _poly_nodes.end(); ++j) { if (j->second->edges().empty()) { - this_connect_node = j->second; + this_connect_node = j->second; this_connect_node_end_time = j->first + j->second->duration(); break; } @@ -144,17 +149,20 @@ MachineBuilder::event(Raul::TimeStamp time_offset, // Currently monophonic, or didn't find a poly node, so use _connect_node // which is maintained below on note off events. - if ( ! this_connect_node) { + if (!this_connect_node) { this_connect_node = _connect_node; this_connect_node_end_time = _connect_node_end_time; } SharedPtr delay_node = connect_nodes(_machine, - this_connect_node, this_connect_node_end_time, node, t); + this_connect_node, + this_connect_node_end_time, + node, + t); if (delay_node) { - _connect_node = delay_node; - _connect_node_end_time = t; + _connect_node = delay_node; + _connect_node_end_time = t; } node->enter(NULL, t); @@ -162,21 +170,25 @@ MachineBuilder::event(Raul::TimeStamp time_offset, } else if ((buf[0] & 0xF0) == LV2_MIDI_MSG_NOTE_OFF) { - for (ActiveList::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) { - SharedPtr action = PtrCast((*i)->enter_action()); - if (!action) + for (ActiveList::iterator i = _active_nodes.begin(); + i != _active_nodes.end(); ++i) { + SharedPtr action = PtrCast( + (*i)->enter_action()); + if (!action) { continue; + } const size_t ev_size = action->event_size(); const unsigned char* ev = action->event(); - if (ev_size == 3 && (ev[0] & 0xF0) == LV2_MIDI_MSG_NOTE_ON - && (ev[0] & 0x0F) == (buf[0] & 0x0F) // same channel - && ev[1] == buf[1]) // same note - { + if ((ev_size == 3) && ((ev[0] & 0xF0) == LV2_MIDI_MSG_NOTE_ON) + && ((ev[0] & 0x0F) == (buf[0] & 0x0F)) // same channel + && (ev[1] == buf[1])) { + // same note SharedPtr resolved = *i; - resolved->set_exit_action(SharedPtr(new MidiAction(ev_size, buf))); + resolved->set_exit_action( + SharedPtr(new MidiAction(ev_size, buf))); set_node_duration(resolved, t - resolved->enter_time()); // Last active note @@ -192,35 +204,45 @@ MachineBuilder::event(Raul::TimeStamp time_offset, connect_nodes(_machine, resolved, t, _connect_node, t); - for (PolyList::iterator j = _poly_nodes.begin(); j != _poly_nodes.end(); ++j) { + for (PolyList::iterator j = _poly_nodes.begin(); + j != _poly_nodes.end(); ++j) { _machine->add_node(j->second); - if (j->second->edges().size() == 0) - connect_nodes(_machine, j->second, j->first + j->second->duration(), - _connect_node, t); + if (j->second->edges().size() == 0) { + connect_nodes(_machine, j->second, + j->first + j->second->duration(), + _connect_node, t); + } } _poly_nodes.clear(); _machine->add_node(resolved); - // Just monophonic + // Just monophonic } else { // Trim useless delay node if possible (these appear after poly sections) - if (is_delay_node(_connect_node) && _connect_node->duration().is_zero() - && _connect_node->edges().size() == 1 - && (*_connect_node->edges().begin())->head() == resolved) { + if (is_delay_node(_connect_node) + && _connect_node->duration().is_zero() + && ( _connect_node->edges().size() == 1) + && ( (*_connect_node->edges().begin())->head() == + resolved) ) { _connect_node->edges().clear(); assert(_connect_node->edges().empty()); - _connect_node->set_enter_action(resolved->enter_action()); - _connect_node->set_exit_action(resolved->exit_action()); + _connect_node->set_enter_action( + resolved->enter_action()); + _connect_node->set_exit_action( + resolved->exit_action()); resolved->set_enter_action(SharedPtr()); resolved->set_exit_action(SharedPtr()); set_node_duration(_connect_node, resolved->duration()); resolved = _connect_node; - if (std::find(_machine->nodes().begin(), _machine->nodes().end(), _connect_node) - == _machine->nodes().end()) + if (std::find(_machine->nodes().begin(), + _machine->nodes().end(), + _connect_node) + == _machine->nodes().end()) { _machine->add_node(_connect_node); + } } else { _connect_node = resolved; @@ -228,15 +250,17 @@ MachineBuilder::event(Raul::TimeStamp time_offset, } } - // Polyphonic, add this state to poly list + // Polyphonic, add this state to poly list } else { - _poly_nodes.push_back(make_pair(resolved->enter_time(), resolved)); - _connect_node = resolved; + _poly_nodes.push_back(make_pair(resolved->enter_time(), + resolved)); + _connect_node = resolved; _connect_node_end_time = t; } - if (resolved->is_active()) + if (resolved->is_active()) { resolved->exit(NULL, t); + } _active_nodes.erase(i); @@ -254,18 +278,26 @@ void MachineBuilder::resolve() { // Resolve stuck notes - if ( ! _active_nodes.empty()) { - for (list >::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) { + if (!_active_nodes.empty()) { + for (list >::iterator i = _active_nodes.begin(); + i != _active_nodes.end(); ++i) { cerr << "WARNING: Resolving stuck note." << endl; - SharedPtr action = PtrCast((*i)->enter_action()); - if (!action) + SharedPtr action = PtrCast( + (*i)->enter_action()); + if (!action) { continue; + } const size_t ev_size = action->event_size(); const unsigned char* ev = action->event(); - if (ev_size == 3 && (ev[0] & 0xF0) == LV2_MIDI_MSG_NOTE_ON) { - unsigned char note_off[3] = { ((LV2_MIDI_MSG_NOTE_OFF & 0xF0) | (ev[0] & 0x0F)), ev[1], 0x40 }; - (*i)->set_exit_action(SharedPtr(new MidiAction(3, note_off))); + if (( ev_size == 3) + && ( (ev[0] & 0xF0) == LV2_MIDI_MSG_NOTE_ON) ) { + unsigned char note_off[3] + = { ((LV2_MIDI_MSG_NOTE_OFF & 0xF0) | (ev[0] & 0x0F)), + ev[1], + 0x40 }; + (*i)->set_exit_action( + SharedPtr(new MidiAction(3, note_off))); set_node_duration((*i), _time - (*i)->enter_time()); (*i)->exit(NULL, _time); _machine->add_node((*i)); @@ -275,10 +307,12 @@ MachineBuilder::resolve() } // Add initial note if necessary - if (_machine->nodes().size() > 0 - && (std::find(_machine->nodes().begin(), _machine->nodes().end(), _initial_node) - == _machine->nodes().end())) + if (( _machine->nodes().size() > 0) + && (std::find(_machine->nodes().begin(), _machine->nodes().end(), + _initial_node) + == _machine->nodes().end())) { _machine->add_node(_initial_node); + } } diff --git a/src/engine/MachineBuilder.hpp b/src/engine/MachineBuilder.hpp index c3d4c52..7bd865d 100644 --- a/src/engine/MachineBuilder.hpp +++ b/src/engine/MachineBuilder.hpp @@ -28,7 +28,8 @@ namespace Machina { class Machine; class Node; -class MachineBuilder { +class MachineBuilder +{ public: MachineBuilder(SharedPtr machine, double quantization, @@ -47,10 +48,11 @@ private: bool is_delay_node(SharedPtr node) const; void set_node_duration(SharedPtr node, Raul::TimeDuration d) const; - SharedPtr - connect_nodes(SharedPtr m, - SharedPtr tail, Raul::TimeStamp tail_end_time, - SharedPtr head, Raul::TimeStamp head_start_time); + SharedPtrconnect_nodes(SharedPtr m, + SharedPtr tail, + Raul::TimeStamp tail_end_time, + SharedPtr head, + Raul::TimeStamp head_start_time); typedef std::list > ActiveList; ActiveList _active_nodes; @@ -58,8 +60,8 @@ private: typedef std::list > > PolyList; PolyList _poly_nodes; - double _quantization; - Raul::TimeStamp _time; + double _quantization; + Raul::TimeStamp _time; SharedPtr _machine; SharedPtr _initial_node; diff --git a/src/engine/MidiAction.cpp b/src/engine/MidiAction.cpp index c61ce68..a646f67 100644 --- a/src/engine/MidiAction.cpp +++ b/src/engine/MidiAction.cpp @@ -62,9 +62,10 @@ MidiAction::set_event(size_t size, const byte* new_event) byte* const event = _event.load(); if (size <= _max_size) { _event = NULL; - if (size > 0 && new_event) + if (( size > 0) && new_event) { memcpy(event, new_event, size); - _size = size; + } + _size = size; _event = event; return true; } else { @@ -82,8 +83,9 @@ MidiAction::execute(MIDISink* sink, Raul::TimeStamp time) const byte* const event = _event.load(); if (event) { - if (sink) + if (sink) { sink->write_event(time, _size, event); + } } else { std::cerr << "NULL MIDI ACTION"; } @@ -103,11 +105,10 @@ MidiAction::write_state(Sord::Model& model) // FIXME: Assumes note on/note off std::cerr << "FIXME: AtomRDF" << std::endl; /* - model.add_statement(rdf_id(model.world()), - Sord::Curie(model.world(), "machina:midiNote"), - AtomRDF::atom_to_node(model, Atom((int)(_event.get()[1])))); - */ + model.add_statement(rdf_id(model.world()), + Sord::Curie(model.world(), "machina:midiNote"), + AtomRDF::atom_to_node(model, Atom((int)(_event.get()[1])))); + */ } } // namespace Machina - diff --git a/src/engine/MidiAction.hpp b/src/engine/MidiAction.hpp index 11863c6..96d104c 100644 --- a/src/engine/MidiAction.hpp +++ b/src/engine/MidiAction.hpp @@ -30,7 +30,9 @@ namespace Machina { class MIDISink; -class MidiAction : public Action { +class MidiAction + : public Action +{ public: ~MidiAction(); diff --git a/src/engine/Mutation.cpp b/src/engine/Mutation.cpp index 73fc0e9..e25cdbb 100644 --- a/src/engine/Mutation.cpp +++ b/src/engine/Mutation.cpp @@ -36,12 +36,14 @@ Compress::mutate(Machine& machine) //cout << "COMPRESS" << endl; // Trim disconnected nodes - for (Machine::Nodes::iterator i = machine.nodes().begin(); i != machine.nodes().end() ;) { + for (Machine::Nodes::iterator i = machine.nodes().begin(); + i != machine.nodes().end(); ) { Machine::Nodes::iterator next = i; ++next; - if ((*i)->edges().empty()) + if ((*i)->edges().empty()) { machine.remove_node(*i); + } i = next; } @@ -57,14 +59,17 @@ AddNode::mutate(Machine& machine) node->set_selector(true); SharedPtr note_node = machine.random_node(); - if (!note_node) + if (!note_node) { return; + } uint8_t note = rand() % 128; - SharedPtr enter_action = PtrCast(note_node->enter_action()); - if (enter_action) + SharedPtr enter_action = PtrCast( + note_node->enter_action()); + if (enter_action) { note = enter_action->event()[1]; + } node->set_enter_action(ActionFactory::note_on(note)); node->set_exit_action(ActionFactory::note_off(note)); @@ -72,13 +77,15 @@ AddNode::mutate(Machine& machine) // Insert after some node SharedPtr tail = machine.random_node(); - if (tail && tail != node/* && !node->connected_to(tail)*/) + if (tail && (tail != node) /* && !node->connected_to(tail)*/) { tail->add_edge(boost::shared_ptr(new Edge(tail, node))); + } // Insert before some other node SharedPtr head = machine.random_node(); - if (head && head != node/* && !head->connected_to(node)*/) + if (head && (head != node) /* && !head->connected_to(node)*/) { node->add_edge(boost::shared_ptr(new Edge(node, head))); + } } void @@ -87,8 +94,9 @@ RemoveNode::mutate(Machine& machine) //cout << "REMOVE NODE" << endl; SharedPtr node = machine.random_node(); - if (node && !node->is_initial()) + if (node && !node->is_initial()) { machine.remove_node(node); + } } void @@ -98,12 +106,14 @@ AdjustNode::mutate(Machine& machine) SharedPtr node = machine.random_node(); if (node) { - SharedPtr enter_action = PtrCast(node->enter_action()); - SharedPtr exit_action = PtrCast(node->exit_action()); + SharedPtr enter_action = PtrCast( + node->enter_action()); + SharedPtr exit_action = PtrCast( + node->exit_action()); if (enter_action && exit_action) { const uint8_t note = rand() % 128; enter_action->event()[1] = note; - exit_action->event()[1] = note; + exit_action->event()[1] = note; } node->set_changed(); } @@ -114,13 +124,15 @@ SwapNodes::mutate(Machine& machine) { //cout << "SWAP NODE" << endl; - if (machine.nodes().size() <= 1) + if (machine.nodes().size() <= 1) { return; + } SharedPtr a = machine.random_node(); SharedPtr b = machine.random_node(); - while (b == a) + while (b == a) { b = machine.random_node(); + } SharedPtr a_enter = PtrCast(a->enter_action()); SharedPtr a_exit = PtrCast(a->exit_action()); @@ -131,9 +143,9 @@ SwapNodes::mutate(Machine& machine) uint8_t note_b = b_enter->event()[1]; a_enter->event()[1] = note_b; - a_exit->event()[1] = note_b; + a_exit->event()[1] = note_b; b_enter->event()[1] = note_a; - b_exit->event()[1] = note_a; + b_exit->event()[1] = note_a; } void @@ -144,7 +156,8 @@ AddEdge::mutate(Machine& machine) SharedPtr tail = machine.random_node(); SharedPtr head = machine.random_node(); - if (tail && head && tail != head/* && !tail->connected_to(head) && !head->connected_to(tail)*/) { + if (tail && head && tail != head) { + // && !tail->connected_to(head) && !head->connected_to(tail) SharedPtr edge(new Edge(tail, head)); edge->set_probability(rand() / (float)RAND_MAX); tail->add_edge(boost::shared_ptr(new Edge(tail, head))); @@ -157,8 +170,9 @@ RemoveEdge::mutate(Machine& machine) //cout << "REMOVE EDGE" << endl; SharedPtr tail = machine.random_node(); - if (tail && !(tail->is_initial() && tail->edges().size() == 1)) + if (tail && !(tail->is_initial() && tail->edges().size() == 1)) { tail->remove_edge(tail->random_edge()); + } } void @@ -175,4 +189,3 @@ AdjustEdge::mutate(Machine& machine) } // namespace Mutation } // namespace Machina - diff --git a/src/engine/Node.cpp b/src/engine/Node.cpp index 744d7ac..c0e4654 100644 --- a/src/engine/Node.cpp +++ b/src/engine/Node.cpp @@ -39,12 +39,12 @@ Node::Node(TimeDuration duration, bool initial) , _is_initial(initial) , _is_selector(false) , _is_active(false) -{ -} +{} Node::Node(const Node& copy) - : Stateful() // don't copy RDF ID - , _enter_time(copy._enter_time) + : Stateful() + , // don't copy RDF ID + _enter_time(copy._enter_time) , _duration(copy._duration) , _enter_action(ActionFactory::copy(copy._enter_action)) , _exit_action(ActionFactory::copy(copy._exit_action)) @@ -52,7 +52,8 @@ Node::Node(const Node& copy) , _is_selector(copy._is_selector) , _is_active(false) { - for (Edges::const_iterator i = copy._edges.begin(); i != copy._edges.end(); ++i) { + for (Edges::const_iterator i = copy._edges.begin(); i != copy._edges.end(); + ++i) { SharedPtr edge(new Edge(*i->get())); _edges.push_back(edge); } @@ -63,13 +64,15 @@ SharedPtr Node::random_edge() { SharedPtr ret; - if (_edges.empty()) + if (_edges.empty()) { return ret; + } size_t i = rand() % _edges.size(); // FIXME: O(n) worst case :( - for (Edges::const_iterator e = _edges.begin(); e != _edges.end(); ++e, --i) { + for (Edges::const_iterator e = _edges.begin(); e != _edges.end(); ++e, + --i) { if (i == 0) { ret = *e; break; @@ -82,17 +85,20 @@ Node::random_edge() void Node::edges_changed() { - if ( ! _is_selector) + if (!_is_selector) { return; + } // Normalize edge probabilities if we're a selector double prob_sum = 0; - for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) + for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) { prob_sum += (*i)->probability(); + } - for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) + for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) { (*i)->set_probability((*i)->probability() / prob_sum); + } _changed = true; } @@ -102,8 +108,9 @@ Node::set_selector(bool yn) { _is_selector = yn; - if (yn) + if (yn) { edges_changed(); + } _changed = true; } @@ -112,14 +119,14 @@ void Node::set_enter_action(SharedPtr action) { _enter_action = action; - _changed = true; + _changed = true; } void Node::set_exit_action(SharedPtr action) { _exit_action = action; - _changed = true; + _changed = true; } void @@ -127,12 +134,13 @@ Node::enter(MIDISink* sink, TimeStamp time) { assert(!_is_active); - _changed = true; - _is_active = true; + _changed = true; + _is_active = true; _enter_time = time; - if (sink && _enter_action) + if (sink && _enter_action) { _enter_action->execute(sink, time); + } } void @@ -140,11 +148,12 @@ Node::exit(MIDISink* sink, TimeStamp time) { assert(_is_active); - if (sink && _exit_action) + if (sink && _exit_action) { _exit_action->execute(sink, time); + } - _changed = true; - _is_active = false; + _changed = true; + _is_active = false; _enter_time = 0; } @@ -152,9 +161,11 @@ void Node::add_edge(SharedPtr edge) { assert(edge->tail().lock().get() == this); - for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) - if ((*i)->head() == edge->head()) + for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) { + if ((*i)->head() == edge->head()) { return; + } + } _edges.push_back(edge); edges_changed(); @@ -170,9 +181,11 @@ Node::remove_edge(SharedPtr edge) bool Node::connected_to(SharedPtr node) { - for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) - if ((*i)->head() == node) + for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i) { + if ((*i)->head() == node) { return true; + } + } return false; } @@ -211,29 +224,29 @@ Node::write_state(Sord::Model& model) if (_is_selector) model.add_statement( - rdf_id, - Sord::Curie(model.world(), "rdf:type"), - Sord::Curie(model.world(), "machina:SelectorNode")); + rdf_id, + Sord::Curie(model.world(), "rdf:type"), + Sord::Curie(model.world(), "machina:SelectorNode")); else model.add_statement( - rdf_id, - Sord::Curie(model.world(), "rdf:type"), - Sord::Curie(model.world(), "machina:Node")); + rdf_id, + Sord::Curie(model.world(), "rdf:type"), + Sord::Curie(model.world(), "machina:Node")); std::cerr << "ATOMRDF" << std::endl; /* - model.add_statement( - rdf_id, - Sord::Curie(model.world(), "machina:duration"), - AtomRDF::atom_to_node(model, Atom((float)_duration.to_double()))); - */ + model.add_statement( + rdf_id, + Sord::Curie(model.world(), "machina:duration"), + AtomRDF::atom_to_node(model, Atom((float)_duration.to_double()))); + */ if (_enter_action) { - _enter_action->write_state(model); + _enter_action->write_state(model); - model.add_statement(rdf_id, - Sord::Curie(model.world(), "machina:enterAction"), - _enter_action->rdf_id(model.world())); + model.add_statement(rdf_id, + Sord::Curie(model.world(), "machina:enterAction"), + _enter_action->rdf_id(model.world())); } if (_exit_action) { @@ -246,4 +259,3 @@ Node::write_state(Sord::Model& model) } } // namespace Machina - diff --git a/src/engine/Node.hpp b/src/engine/Node.hpp index 76995b5..cf41b26 100644 --- a/src/engine/Node.hpp +++ b/src/engine/Node.hpp @@ -42,9 +42,11 @@ using Raul::TimeUnit; * Initial nodes do not have enter actions (since they are entered at * an undefined point in time <= 0). */ -class Node : public Stateful { +class Node + : public Stateful +{ public: - Node(TimeDuration duration, bool initial=false); + Node(TimeDuration duration, bool initial = false); Node(const Node& copy); void set_enter_action(SharedPtr action); @@ -58,10 +60,10 @@ public: void edges_changed(); - void add_edge(SharedPtr edge); - void remove_edge(SharedPtr edge); + void add_edge(SharedPtr edge); + void remove_edge(SharedPtr edge); SharedPtr remove_edge_to(SharedPtr node); - bool connected_to(SharedPtr node); + bool connected_to(SharedPtr node); void set(URIInt key, const Raul::Atom& value); void write_state(Sord::Model& model); @@ -69,10 +71,10 @@ public: 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; } + TimeStamp enter_time() const { return _enter_time; } + TimeStamp exit_time() const { return _enter_time + _duration; } TimeDuration duration() const { return _duration; } - void set_duration(TimeDuration d) { _duration = d; } + void set_duration(TimeDuration d) { _duration = d; } bool is_selector() const { return _is_selector; } void set_selector(bool i); diff --git a/src/engine/Problem.cpp b/src/engine/Problem.cpp index 7607829..5c5992d 100644 --- a/src/engine/Problem.cpp +++ b/src/engine/Problem.cpp @@ -38,12 +38,13 @@ using namespace std; namespace Machina { -Problem::Problem(TimeUnit unit, const std::string& target_midi, SharedPtr seed) +Problem::Problem(TimeUnit unit, const std::string& target_midi, + SharedPtr seed) : _unit(unit) , _target(*this) , _seed(new Machine(*seed.get())) { - SMFReader smf; + SMFReader smf; const bool opened = smf.open(target_midi); assert(opened); @@ -60,7 +61,7 @@ Problem::Problem(TimeUnit unit, const std::string& target_midi, SharedPtr(const_machine); map::const_iterator cached = _fitness.find(&machine); - if (cached != _fitness.end()) + if (cached != _fitness.end()) { return cached->second; + } SharedPtr eval(new Evaluator(*this)); @@ -94,20 +96,21 @@ Problem::fitness(const Machine& const_machine) const // FIXME: timing stuff here isn't right at all... static const unsigned ppqn = MACHINA_PPQN; - Raul::TimeSlice time(ppqn, ppqn, 120.0); + Raul::TimeSlice time(ppqn, ppqn, 120.0); time.set_slice(TimeStamp(_unit, 0, 0), TimeDuration(_unit, 2 * ppqn)); machine.run(time); - if (eval->n_notes() == 0) + if (eval->n_notes() == 0) { return 0.0f; // bad dog - + } TimeStamp end(_unit, time.start_ticks().ticks() + 2 * ppqn); time.set_slice(end, TimeStamp(_unit, 0, 0)); while (eval->n_notes() < _target.n_notes()) { machine.run(time); - if (machine.is_finished()) + if (machine.is_finished()) { machine.reset(time.start_ticks()); + } time.set_slice(end, TimeStamp(end.unit(), 0, 0)); } @@ -117,11 +120,11 @@ Problem::fitness(const Machine& const_machine) const #if 0 float f = 0; - for (uint8_t i=0; i < 128; ++i) { + for (uint8_t i = 0; i < 128; ++i) { /*if (eval->_note_frequency[i] <= _target._note_frequency[i]) - f += eval->_note_frequency[i]; - else - f -= _target._note_frequency[i] - eval->_note_frequency[i];*/ + f += eval->_note_frequency[i]; + else + f -= _target._note_frequency[i] - eval->_note_frequency[i];*/ //f -= fabs(eval->_note_frequency[i] - _target._note_frequency[i]); } #endif @@ -132,24 +135,30 @@ Problem::fitness(const Machine& const_machine) const float f = 0.0; - for (Evaluator::Patterns::const_iterator i = eval->_patterns.begin(); i != eval->_patterns.end(); ++i) { + for (Evaluator::Patterns::const_iterator i = eval->_patterns.begin(); + i != eval->_patterns.end(); ++i) { // Reward for matching patterns if (_target._patterns.find(i->first) != _target._patterns.end()) { - Evaluator::Patterns::const_iterator c = _target._patterns.find(i->first); - const uint32_t cnt = (c == _target._patterns.end()) ? 1 : c->second; - f += min(i->second, cnt) * (i->first.length()); + Evaluator::Patterns::const_iterator c = _target._patterns.find( + i->first); + const uint32_t cnt + = (c == _target._patterns.end()) ? 1 : c->second; + f += min(i->second, cnt) * (i->first.length()); - // Punish for bad patterns } else { + // Punish for bad patterns const uint32_t invlen = (eval->_order - i->first.length() + 1); - f -= (i->second / (float)eval->_patterns.size() * (float)(invlen*invlen*invlen)) * 4; + f -= (i->second / (float)eval->_patterns.size() + * (float)(invlen * invlen * invlen)) * 4; } } // Punish for missing patterns - for (Evaluator::Patterns::const_iterator i = _target._patterns.begin(); i != _target._patterns.end(); ++i) { + for (Evaluator::Patterns::const_iterator i = _target._patterns.begin(); + i != _target._patterns.end(); ++i) { if (eval->_patterns.find(i->first) == _target._patterns.end()) { - f -= i->second / (float)_target.n_notes() * (float)(eval->_order - i->first.length() + 1); + f -= i->second / (float)_target.n_notes() + * (float)(eval->_order - i->first.length() + 1); } } @@ -169,28 +178,31 @@ Problem::Evaluator::write_event(Raul::TimeStamp time, const uint8_t note = ev[1]; - if (_first_note == 0) + if (_first_note == 0) { _first_note = note; + } /*++_note_frequency[note]; - ++n_notes();*/ + ++n_notes();*/ //_notes.push_back(note); if (_read.length() == 0) { _read = note; return; } - if (_read.length() == _order) + if (_read.length() == _order) { _read = _read.substr(1); + } _read = _read + (char)note; for (size_t i = 0; i < _read.length(); ++i) { - const string pattern = _read.substr(i); - Patterns::iterator i = _patterns.find(pattern); - if (i != _patterns.end()) + const string pattern = _read.substr(i); + Patterns::iterator i = _patterns.find(pattern); + if (i != _patterns.end()) { ++(i->second); - else + } else { _patterns[pattern] = 1; + } } ++_counts[note]; @@ -203,12 +215,12 @@ void Problem::Evaluator::compute() { /* - for (uint8_t i=0; i < 128; ++i) { - if (_note_frequency[i] > 0) { - _note_frequency[i] /= (float)n_notes(); - //cout << (int)i << ":\t" << _note_frequency[i] << endl; - } - }*/ + for (uint8_t i=0; i < 128; ++i) { + if (_note_frequency[i] > 0) { + _note_frequency[i] /= (float)n_notes(); + //cout << (int)i << ":\t" << _note_frequency[i] << endl; + } + }*/ } boost::shared_ptr @@ -219,10 +231,10 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const // FIXME: ignores _seed and builds based on MIDI // evolution of the visible machine would be nice.. SharedPtr base = SharedPtr(new Machine(_unit)); - for (uint8_t i=0; i < 128; ++i) { + for (uint8_t i = 0; i < 128; ++i) { if (_target._counts[i] > 0) { //cout << "Initial note: " << (int)i << endl; - SharedPtr node(new Node(TimeDuration(_unit, 1/2.0))); + SharedPtr node(new Node(TimeDuration(_unit, 1 / 2.0))); node->set_enter_action(ActionFactory::note_on(i)); node->set_exit_action(ActionFactory::note_off(i)); node->set_selector(true); @@ -235,10 +247,12 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const Machine m(*base.get()); set< SharedPtr > unreachable; - SharedPtr initial; + SharedPtr initial; - for (Machine::Nodes::iterator i = m.nodes().begin(); i != m.nodes().end(); ++i) { - if (PtrCast((*i)->enter_action())->event()[1] == _target.first_note()) { + for (Machine::Nodes::iterator i = m.nodes().begin(); i != m.nodes().end(); + ++i) { + if (PtrCast((*i)->enter_action())->event()[1] == + _target.first_note()) { (*i)->set_initial(true); initial = *i; } else { @@ -250,13 +264,14 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const unreachable.erase(cur); SharedPtr head; - while ( ! unreachable.empty()) { - if (rand() % 2) + while (!unreachable.empty()) { + if (rand() % 2) { head = m.random_node(); - else + } else { head = *unreachable.begin(); + } - if ( ! head->connected_to(head) ) { + if (!head->connected_to(head) ) { cur->add_edge(SharedPtr(new Edge(cur, head))); unreachable.erase(head); cur = head; @@ -266,7 +281,7 @@ Problem::initial_population(size_t gene_size, size_t pop_size) const ret->push_back(m); /*cout << "initial # nodes: " << m.nodes().size(); - cout << "initial fitness: " << fitness(m) << endl;*/ + cout << "initial fitness: " << fitness(m) << endl;*/ } return ret; @@ -286,22 +301,27 @@ Problem::distance(const std::vector& source, const uint16_t n = source.size(); const uint16_t m = target.size(); - if (n == 0) + if (n == 0) { return m; - if (m == 0) + } + if (m == 0) { return n; + } _matrix.resize(n + 1); - for (uint16_t i = 0; i <= n; i++) - _matrix[i].resize (m + 1); + for (uint16_t i = 0; i <= n; i++) { + _matrix[i].resize(m + 1); + } // Step 2 - for (uint16_t i = 0; i <= n; i++) + for (uint16_t i = 0; i <= n; i++) { _matrix[i][0] = i; + } - for (uint16_t j = 0; j <= m; j++) + for (uint16_t j = 0; j <= m; j++) { _matrix[0][j] = j; + } // Step 3 @@ -327,9 +347,9 @@ Problem::distance(const std::vector& source, // Step 6 const uint16_t above = _matrix[i - 1][j]; - const uint16_t left = _matrix[i][j - 1]; - const uint16_t diag = _matrix[i - 1][j - 1]; - uint16_t cell = min (above + 1, min (left + 1, diag + cost)); + const uint16_t left = _matrix[i][j - 1]; + const uint16_t diag = _matrix[i - 1][j - 1]; + uint16_t cell = min(above + 1, min(left + 1, diag + cost)); // Step 6A: Cover transposition, in addition to deletion, // insertion and substitution. This step is taken from: @@ -337,14 +357,17 @@ Problem::distance(const std::vector& source, // Enhanced Dynamic Programming ASM Algorithm" // (http://www.acm.org/~hlb/publications/asm/asm.html) - if (i > 2 && j > 2) { + if (( i > 2) && ( j > 2) ) { uint16_t trans = _matrix[i - 2][j - 2] + 1; - if (source[i - 2] != t_j) + if (source[i - 2] != t_j) { trans++; - if (s_i != target[j - 2]) + } + if (s_i != target[j - 2]) { trans++; - if (cell > trans) + } + if (cell > trans) { cell = trans; + } } _matrix[i][j] = cell; @@ -357,4 +380,3 @@ Problem::distance(const std::vector& source, } } // namespace Machina - diff --git a/src/engine/Recorder.cpp b/src/engine/Recorder.cpp index 4a67f65..8bc9a4a 100644 --- a/src/engine/Recorder.cpp +++ b/src/engine/Recorder.cpp @@ -35,9 +35,8 @@ Recorder::Recorder(Raul::Forge& forge, , _unit(unit) , _record_buffer(buffer_size) , _builder(new MachineBuilder( - SharedPtr(new Machine(unit)), q, step)) -{ -} + SharedPtr(new Machine(unit)), q, step)) +{} void Recorder::_whipped() @@ -72,4 +71,3 @@ Recorder::finish() } } - diff --git a/src/engine/Recorder.hpp b/src/engine/Recorder.hpp index 9c669b9..ce9cad8 100644 --- a/src/engine/Recorder.hpp +++ b/src/engine/Recorder.hpp @@ -29,7 +29,9 @@ namespace Machina { class MachineBuilder; -class Recorder : public Slave { +class Recorder + : public Slave +{ public: Recorder(Raul::Forge& forge, size_t buffer_size, @@ -37,8 +39,10 @@ public: double q, bool step); - inline void write(Raul::TimeStamp time, size_t size, const unsigned char* buf) { - if (_record_buffer.write_space() < (sizeof(TimeStamp) + sizeof(size_t) + size)) { + inline void write(Raul::TimeStamp time, size_t size, + const unsigned char* buf) { + if (_record_buffer.write_space() < + (sizeof(TimeStamp) + sizeof(size_t) + size)) { std::cerr << "Record buffer overflow" << std::endl; return; } else { diff --git a/src/engine/SMFDriver.cpp b/src/engine/SMFDriver.cpp index 641baf9..a07f47d 100644 --- a/src/engine/SMFDriver.cpp +++ b/src/engine/SMFDriver.cpp @@ -49,11 +49,13 @@ SMFDriver::SMFDriver(Raul::Forge& forge, Raul::TimeUnit unit) * @return the resulting machine. */ SharedPtr -SMFDriver::learn(const string& filename, unsigned track, double q, Raul::TimeDuration max_duration) +SMFDriver::learn(const string& filename, unsigned track, double q, + Raul::TimeDuration max_duration) { //assert(q.unit() == max_duration.unit()); - SharedPtr m(new Machine(max_duration.unit())); - SharedPtr builder = SharedPtr(new MachineBuilder(m, q, false)); + SharedPtr m(new Machine(max_duration.unit())); + SharedPtr builder = SharedPtr( + new MachineBuilder(m, q, false)); SMFReader reader; if (!reader.open(filename)) { @@ -61,17 +63,19 @@ SMFDriver::learn(const string& filename, unsigned track, double q, Raul::TimeDur return SharedPtr(); } - if (track > reader.num_tracks()) + if (track > reader.num_tracks()) { return SharedPtr(); - else + } else { learn_track(builder, reader, track, q, max_duration); + } m->reset(NULL, m->time()); - if (m->nodes().size() > 1) + if (m->nodes().size() > 1) { return m; - else + } else { return SharedPtr(); + } } /** Learn all tracks from a MIDI file into a single machine. @@ -81,8 +85,9 @@ SMFDriver::learn(const string& filename, unsigned track, double q, Raul::TimeDur SharedPtr SMFDriver::learn(const string& filename, double q, Raul::TimeStamp max_duration) { - SharedPtr m(new Machine(max_duration.unit())); - SharedPtr builder = SharedPtr(new MachineBuilder(m, q, false)); + SharedPtr m(new Machine(max_duration.unit())); + SharedPtr builder = SharedPtr( + new MachineBuilder(m, q, false)); SMFReader reader; if (!reader.open(filename)) { @@ -90,17 +95,18 @@ SMFDriver::learn(const string& filename, double q, Raul::TimeStamp max_duration) return SharedPtr(); } - for (unsigned t=1; t <= reader.num_tracks(); ++t) { + for (unsigned t = 1; t <= reader.num_tracks(); ++t) { builder->reset(); learn_track(builder, reader, t, q, max_duration); } m->reset(NULL, m->time()); - if (m->nodes().size() > 1) + if (m->nodes().size() > 1) { return m; - else + } else { return SharedPtr(); + } } void @@ -111,27 +117,30 @@ SMFDriver::learn_track(SharedPtr builder, Raul::TimeDuration max_duration) { const bool found_track = reader.seek_to_track(track); - if (!found_track) + if (!found_track) { return; + } uint8_t buf[4]; uint32_t ev_size; uint32_t ev_delta_time; - uint64_t t = 0; + uint64_t t = 0; double unquantized_t = 0; while (reader.read_event(4, buf, &ev_size, &ev_delta_time) >= 0) { unquantized_t += ev_delta_time; - t = quantize(q, unquantized_t); + t = quantize(q, unquantized_t); builder->set_time(TimeStamp(max_duration.unit(), (double)t)); - if ((!max_duration.is_zero()) && t > max_duration.to_double()) + if ((!max_duration.is_zero()) && ( t > max_duration.to_double()) ) { break; + } - if (ev_size > 0) + if (ev_size > 0) { builder->event(TimeStamp(max_duration.unit(), 0, 0), ev_size, buf); + } } builder->resolve(); @@ -141,9 +150,11 @@ void SMFDriver::run(SharedPtr machine, Raul::TimeStamp max_time) { // FIXME: unit kludge (tempo only) - Context context(_forge, machine->time().unit().ppt(), _writer->unit().ppt(), 120.0); + Context context(_forge, machine->time().unit().ppt(), + _writer->unit().ppt(), 120.0); context.set_sink(this); - context.time().set_slice(TimeStamp(max_time.unit(), 0, 0), context.time().beats_to_ticks(max_time)); + context.time().set_slice(TimeStamp(max_time.unit(), 0, 0), + context.time().beats_to_ticks(max_time)); machine->run(context, SharedPtr()); } diff --git a/src/engine/SMFDriver.hpp b/src/engine/SMFDriver.hpp index f978849..abed40d 100644 --- a/src/engine/SMFDriver.hpp +++ b/src/engine/SMFDriver.hpp @@ -34,7 +34,9 @@ namespace Machina { class Node; class Machine; -class SMFDriver : public Driver { +class SMFDriver + : public Driver +{ public: SMFDriver(Raul::Forge& forge, Raul::TimeUnit unit); @@ -54,8 +56,8 @@ public: const unsigned char* ev) throw (std::logic_error) { _writer->write_event(time, ev_size, ev); } - void set_bpm(double /*bpm*/) { } - void set_quantization(double /*quantization*/) { } + void set_bpm(double /*bpm*/) {} + void set_quantization(double /*quantization*/) {} SharedPtr writer() { return _writer; } @@ -72,4 +74,3 @@ private: } // namespace Machina #endif // MACHINA_SMFDRIVER_HPP - diff --git a/src/engine/SMFReader.cpp b/src/engine/SMFReader.cpp index cba1fb0..62cdd26 100644 --- a/src/engine/SMFReader.cpp +++ b/src/engine/SMFReader.cpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -40,31 +40,31 @@ midi_event_size(unsigned char status) } switch (status) { - case LV2_MIDI_MSG_NOTE_OFF: - case LV2_MIDI_MSG_NOTE_ON: - case LV2_MIDI_MSG_NOTE_PRESSURE: - case LV2_MIDI_MSG_CONTROLLER: - case LV2_MIDI_MSG_BENDER: - case LV2_MIDI_MSG_SONG_POS: - return 2; - - case LV2_MIDI_MSG_PGM_CHANGE: - case LV2_MIDI_MSG_CHANNEL_PRESSURE: - case LV2_MIDI_MSG_MTC_QUARTER: - case LV2_MIDI_MSG_SONG_SELECT: - return 1; - - case LV2_MIDI_MSG_TUNE_REQUEST: - case LV2_MIDI_MSG_CLOCK: - case LV2_MIDI_MSG_START: - case LV2_MIDI_MSG_CONTINUE: - case LV2_MIDI_MSG_STOP: - case LV2_MIDI_MSG_ACTIVE_SENSE: - case LV2_MIDI_MSG_RESET: - return 0; + case LV2_MIDI_MSG_NOTE_OFF: + case LV2_MIDI_MSG_NOTE_ON: + case LV2_MIDI_MSG_NOTE_PRESSURE: + case LV2_MIDI_MSG_CONTROLLER: + case LV2_MIDI_MSG_BENDER: + case LV2_MIDI_MSG_SONG_POS: + return 2; + + case LV2_MIDI_MSG_PGM_CHANGE: + case LV2_MIDI_MSG_CHANNEL_PRESSURE: + case LV2_MIDI_MSG_MTC_QUARTER: + case LV2_MIDI_MSG_SONG_SELECT: + return 1; + + case LV2_MIDI_MSG_TUNE_REQUEST: + case LV2_MIDI_MSG_CLOCK: + case LV2_MIDI_MSG_START: + case LV2_MIDI_MSG_CONTINUE: + case LV2_MIDI_MSG_STOP: + case LV2_MIDI_MSG_ACTIVE_SENSE: + case LV2_MIDI_MSG_RESET: + return 0; - case LV2_MIDI_MSG_SYSTEM_EXCLUSIVE: - return -1; + case LV2_MIDI_MSG_SYSTEM_EXCLUSIVE: + return -1; } return -1; @@ -76,21 +76,26 @@ SMFReader::SMFReader(const std::string filename) , _track(0) , _track_size(0) { - if (filename.length() > 0) + if (filename.length() > 0) { open(filename); + } } SMFReader::~SMFReader() { - if (_fd) + if (_fd) { close(); + } } bool -SMFReader::open(const std::string& filename) throw (std::logic_error, UnsupportedTime) +SMFReader::open(const std::string& filename) + throw (std::logic_error, UnsupportedTime) { - if (_fd) - throw std::logic_error("Attempt to start new read while write in progress."); + if (_fd) { + throw std::logic_error( + "Attempt to start new read while write in progress."); + } std::cout << "Opening SMF file " << filename << " for reading." << endl; @@ -126,8 +131,9 @@ SMFReader::open(const std::string& filename) throw (std::logic_error, Unsupporte _ppqn = GUINT16_FROM_BE(ppqn_be); // TODO: Absolute (SMPTE seconds) time support - if ((_ppqn & 0x8000) != 0) + if ((_ppqn & 0x8000) != 0) { throw UnsupportedTime(); + } seek_to_track(1); @@ -143,11 +149,13 @@ SMFReader::open(const std::string& filename) throw (std::logic_error, Unsupporte bool SMFReader::seek_to_track(unsigned track) throw (std::logic_error) { - if (track == 0) + if (track == 0) { throw std::logic_error("Seek to track 0 out of range (must be >= 1)"); + } - if (!_fd) + if (!_fd) { throw std::logic_error("Attempt to seek to track on unopened SMF file."); + } unsigned track_pos = 0; @@ -169,14 +177,15 @@ SMFReader::seek_to_track(unsigned track) throw (std::logic_error) fread(&chunk_size_be, 4, 1, _fd); chunk_size = GUINT32_FROM_BE(chunk_size_be); - if (track_pos == track) + if (track_pos == track) { break; + } fseek(_fd, chunk_size, SEEK_CUR); } - if (!feof(_fd) && track_pos == track) { - _track = track; + if (!feof(_fd) && ( track_pos == track) ) { + _track = track; _track_size = chunk_size; return true; } else { @@ -204,8 +213,9 @@ SMFReader::read_event(size_t buf_len, uint32_t* delta_time) throw (std::logic_error, PrematureEOF, CorruptFile) { - if (_track == 0) + if (_track == 0) { throw std::logic_error("Attempt to read from unopened SMF file"); + } if (!_fd || feof(_fd)) { return -1; @@ -222,30 +232,33 @@ SMFReader::read_event(size_t buf_len, *delta_time = read_var_len(_fd); int status = fgetc(_fd); - if (status == EOF) + if (status == EOF) { throw PrematureEOF(); - else if (status > 0xFF) + } else if (status > 0xFF) { throw CorruptFile(); + } if (status < 0x80) { - if (last_status == 0) + if (last_status == 0) { throw CorruptFile(); - status = last_status; + } + status = last_status; *ev_size = last_size; fseek(_fd, -1, SEEK_CUR); } else { last_status = status; - *ev_size = midi_event_size(status) + 1; - last_size = *ev_size; + *ev_size = midi_event_size(status) + 1; + last_size = *ev_size; } buf[0] = static_cast(status); if (status == 0xFF) { *ev_size = 0; - if (feof(_fd)) + if (feof(_fd)) { throw PrematureEOF(); - uint8_t type = fgetc(_fd); + } + uint8_t type = fgetc(_fd); const uint32_t size = read_var_len(_fd); if (type == 0x2F) { @@ -256,18 +269,19 @@ SMFReader::read_event(size_t buf_len, } } - if (*ev_size > buf_len || *ev_size == 0 || feof(_fd)) { + if ((*ev_size > buf_len) || (*ev_size == 0) || feof(_fd)) { // Skip event, return 0 fseek(_fd, *ev_size - 1, SEEK_CUR); return 0; } else { // Read event, return size - if (ferror(_fd)) + if (ferror(_fd)) { throw CorruptFile(); + } - fread(buf+1, 1, *ev_size - 1, _fd); + fread(buf + 1, 1, *ev_size - 1, _fd); - if ((buf[0] & 0xF0) == 0x90 && buf[2] == 0) { + if (((buf[0] & 0xF0) == 0x90) && (buf[2] == 0) ) { buf[0] = (0x80 | (buf[0] & 0x0F)); buf[2] = 0x40; } @@ -279,8 +293,9 @@ SMFReader::read_event(size_t buf_len, void SMFReader::close() { - if (_fd) + if (_fd) { fclose(_fd); + } _fd = NULL; } @@ -288,17 +303,19 @@ SMFReader::close() uint32_t SMFReader::read_var_len(FILE* fd) throw (PrematureEOF) { - if (feof(fd)) + if (feof(fd)) { throw PrematureEOF(); + } uint32_t value; uint8_t c; - if ( (value = getc(fd)) & 0x80 ) { + if ( (value = getc(fd)) & 0x80) { value &= 0x7F; do { - if (feof(fd)) + if (feof(fd)) { throw PrematureEOF(); + } value = (value << 7) + ((c = getc(fd)) & 0x7F); } while (c & 0x80); } @@ -307,4 +324,3 @@ SMFReader::read_var_len(FILE* fd) throw (PrematureEOF) } } // namespace Machina - diff --git a/src/engine/SMFReader.hpp b/src/engine/SMFReader.hpp index 053a62c..a3f38ed 100644 --- a/src/engine/SMFReader.hpp +++ b/src/engine/SMFReader.hpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -14,8 +14,8 @@ along with Raul. If not, see . */ -#ifndef RAUL_SMF_READER_HPP -#define RAUL_SMF_READER_HPP +#ifndef MACHINA_SMF_READER_HPP +#define MACHINA_SMF_READER_HPP #include #include @@ -29,22 +29,31 @@ namespace Machina { * Currently this only reads SMF files with tempo-based timing. * \ingroup raul */ -class SMFReader { +class SMFReader +{ public: - class PrematureEOF : public std::exception { + class PrematureEOF + : public std::exception + { const char* what() const throw() { return "Unexpected end of file"; } }; - class CorruptFile : public std::exception { + class CorruptFile + : public std::exception + { const char* what() const throw() { return "Corrupted file"; } }; - class UnsupportedTime : public std::exception { - const char* what() const throw() { return "Unsupported time stamp type (SMPTE)"; } + class UnsupportedTime + : public std::exception + { + const char* what() const throw() { return + "Unsupported time stamp type (SMPTE)"; } }; - explicit SMFReader(const std::string filename=""); + explicit SMFReader(const std::string filename = ""); ~SMFReader(); - bool open(const std::string& filename) throw (std::logic_error, UnsupportedTime); + bool open(const std::string& filename) throw (std::logic_error, + UnsupportedTime); bool seek_to_track(unsigned track) throw (std::logic_error); @@ -56,7 +65,7 @@ public: uint8_t* buf, uint32_t* ev_size, uint32_t* ev_delta_time) - throw (std::logic_error, PrematureEOF, CorruptFile); + throw (std::logic_error, PrematureEOF, CorruptFile); void close(); @@ -77,5 +86,4 @@ protected: } // namespace Machina -#endif // RAUL_SMF_READER_HPP - +#endif // MACHINA_SMF_READER_HPP diff --git a/src/engine/SMFWriter.cpp b/src/engine/SMFWriter.cpp index ad993bc..41abfe0 100644 --- a/src/engine/SMFWriter.cpp +++ b/src/engine/SMFWriter.cpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -45,14 +45,16 @@ SMFWriter::SMFWriter(Raul::TimeUnit unit) , _track_size(0) , _header_size(0) { - if (unit.type() == Raul::TimeUnit::BEATS) + if (unit.type() == Raul::TimeUnit::BEATS) { assert(unit.ppt() < std::numeric_limits::max()); + } } SMFWriter::~SMFWriter() { - if (_fd) + if (_fd) { finish(); + } } /** Start a write to an SMF file. @@ -65,17 +67,19 @@ bool SMFWriter::start(const std::string& filename, Raul::TimeStamp start_time) throw (std::logic_error) { - if (_fd) - throw std::logic_error("Attempt to start new write while write in progress."); + if (_fd) { + throw std::logic_error( + "Attempt to start new write while write in progress."); + } std::cout << "Opening SMF file " << filename << " for writing." << endl; _fd = fopen(filename.c_str(), "w+"); if (_fd) { - _track_size = 0; - _filename = filename; - _start_time = start_time; + _track_size = 0; + _filename = filename; + _start_time = start_time; _last_ev_time = 0; // write a tentative header to pad file out so writing starts at the right offset write_header(); @@ -95,19 +99,21 @@ SMFWriter::write_event(Raul::TimeStamp time, size_t ev_size, const unsigned char* ev) throw (std::logic_error) { - if (time < _start_time) + if (time < _start_time) { throw std::logic_error("Event time is before file start time"); - else if (time < _last_ev_time) + } else if (time < _last_ev_time) { throw std::logic_error("Event time not monotonically increasing"); - else if (time.unit() != _unit) + } else if (time.unit() != _unit) { throw std::logic_error("Event has unexpected time unit"); + } Raul::TimeStamp delta_time = time; delta_time -= _start_time; fseek(_fd, 0, SEEK_END); - uint64_t delta_ticks = delta_time.ticks() * _unit.ppt() + delta_time.subticks(); + uint64_t delta_ticks = delta_time.ticks() * _unit.ppt() + + delta_time.subticks(); size_t stamp_size = 0; /* If delta time is too long (i.e. overflows), write out empty @@ -127,21 +133,24 @@ SMFWriter::write_event(Raul::TimeStamp time, fwrite(ev, 1, ev_size, _fd); _last_ev_time = time; - _track_size += stamp_size + ev_size; + _track_size += stamp_size + ev_size; } void SMFWriter::flush() { - if (_fd) + if (_fd) { fflush(_fd); + } } void SMFWriter::finish() throw (std::logic_error) { - if (!_fd) - throw std::logic_error("Attempt to finish write with no write in progress."); + if (!_fd) { + throw std::logic_error( + "Attempt to finish write with no write in progress."); + } write_footer(); fclose(_fd); @@ -161,8 +170,8 @@ SMFWriter::write_header() char data[6]; memcpy(data, &type, 2); - memcpy(data+2, &ntracks, 2); - memcpy(data+4, &division, 2); + memcpy(data + 2, &ntracks, 2); + memcpy(data + 4, &division, 2); //data[4] = _ppqn & 0xF0; //data[5] = _ppqn & 0x0F; @@ -214,21 +223,21 @@ SMFWriter::write_var_len(uint32_t value) while ( (value >>= 7) ) { buffer <<= 8; - buffer |= ((value & 0x7F) | 0x80); + buffer |= ((value & 0x7F) | 0x80); } while (true) { //printf("Writing var len byte %X\n", (unsigned char)buffer); ++ret; fputc(buffer, _fd); - if (buffer & 0x80) + if (buffer & 0x80) { buffer >>= 8; - else + } else { break; + } } return ret; } } // namespace Machina - diff --git a/src/engine/SMFWriter.hpp b/src/engine/SMFWriter.hpp index 3e47e9f..ba530a8 100644 --- a/src/engine/SMFWriter.hpp +++ b/src/engine/SMFWriter.hpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -14,8 +14,8 @@ along with Raul. If not, see . */ -#ifndef RAUL_SMF_WRITER_HPP -#define RAUL_SMF_WRITER_HPP +#ifndef MACHINA_SMF_WRITER_HPP +#define MACHINA_SMF_WRITER_HPP #include #include @@ -29,7 +29,9 @@ namespace Machina { /** Standard Midi File (Type 0) Writer * \ingroup raul */ -class SMFWriter : public MIDISink { +class SMFWriter + : public MIDISink +{ public: explicit SMFWriter(Raul::TimeUnit unit); ~SMFWriter(); @@ -53,9 +55,9 @@ protected: void write_header(); void write_footer(); - void write_chunk_header(const char id[4], uint32_t length); - void write_chunk(const char id[4], uint32_t length, void* data); - size_t write_var_len(uint32_t val); + void write_chunk_header(const char id[4], uint32_t length); + void write_chunk(const char id[4], uint32_t length, void* data); + size_t write_var_len(uint32_t val); std::string _filename; FILE* _fd; @@ -68,5 +70,4 @@ protected: } // namespace Machina -#endif // RAUL_SMF_WRITER_HPP - +#endif // MACHINA_SMF_WRITER_HPP diff --git a/src/engine/Schrodinbit.hpp b/src/engine/Schrodinbit.hpp index 16effbf..aca88a2 100644 --- a/src/engine/Schrodinbit.hpp +++ b/src/engine/Schrodinbit.hpp @@ -1,5 +1,5 @@ /* This file is part of Machina. - * Copyright 2007-2011 David Robillard + * Copyright 2007-2012 David Robillard * * Machina is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -18,9 +18,10 @@ #ifndef SCHRODINBIT_HPP #define SCHRODINBIT_HPP -/** A flag which becomes false when it's value is observed +/** A flag which becomes false when its value is observed */ -class Schrodinbit { +class Schrodinbit +{ public: Schrodinbit() : _flag(false) {} @@ -40,4 +41,3 @@ private: }; #endif // SCHRODINBIT_HPP - diff --git a/src/engine/Stateful.cpp b/src/engine/Stateful.cpp index c2d2731..d778b85 100644 --- a/src/engine/Stateful.cpp +++ b/src/engine/Stateful.cpp @@ -23,8 +23,7 @@ uint64_t Stateful::_next_id = 1; Stateful::Stateful() : _id(next_id()) -{ -} +{} const Sord::Node& Stateful::rdf_id(Sord::World& world) const diff --git a/src/engine/Stateful.hpp b/src/engine/Stateful.hpp index 779d8f7..928be3b 100644 --- a/src/engine/Stateful.hpp +++ b/src/engine/Stateful.hpp @@ -24,13 +24,16 @@ #include "machina/types.hpp" -namespace Raul { class Atom; } +namespace Raul { +class Atom; +} namespace Machina { class URIs; -class Stateful { +class Stateful +{ public: Stateful(); @@ -39,7 +42,7 @@ public: virtual void set(URIInt key, const Raul::Atom& value) {} virtual void write_state(Sord::Model& model) = 0; - uint64_t id() const { return _id; } + uint64_t id() const { return _id; } const Sord::Node& rdf_id(Sord::World& world) const; static uint64_t next_id() { return _next_id++; } @@ -50,11 +53,13 @@ protected: private: static uint64_t _next_id; - uint64_t _id; + uint64_t _id; mutable Sord::Node _rdf_id; }; -class StatefulKey : public Stateful { +class StatefulKey + : public Stateful +{ public: StatefulKey(uint64_t id) : Stateful(id) {} diff --git a/src/engine/Updates.cpp b/src/engine/Updates.cpp index aabd4fb..16717e4 100644 --- a/src/engine/Updates.cpp +++ b/src/engine/Updates.cpp @@ -61,8 +61,8 @@ read_set(SharedPtr buf, *value = Raul::Atom(atom.size, atom.type, NULL); buf->read(atom.size, value->get_body()); - return sizeof(update_type) + sizeof(*subject) + sizeof(*key) + - sizeof(LV2_Atom) + atom.size; + return sizeof(update_type) + sizeof(*subject) + sizeof(*key) + + sizeof(LV2_Atom) + atom.size; } } diff --git a/src/engine/jack_compat.h b/src/engine/jack_compat.h deleted file mode 100644 index 3d8e990..0000000 --- a/src/engine/jack_compat.h +++ /dev/null @@ -1,55 +0,0 @@ -/* JACK MIDI API compatibility hacks. - * Copyright 2007 Nedko Arnaudov - * - * Machina is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * Machina is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Machina. If not, see . - */ - -#ifndef JACK_COMPAT_H -#define JACK_COMPAT_H - -#if defined(JACK_MIDI_NEEDS_NFRAMES) - -jack_nframes_t -jack_midi_get_event_count_compat( - void * port_buffer) -{ -#if defined(HAVE_OLD_JACK_MIDI) - return jack_midi_port_get_info(port_buffer, 0)->event_count; -#else - return jack_midi_get_event_count(port_buffer, 0); -#endif -} - -#define jack_midi_get_event_count jack_midi_get_event_count_compat - -int -jack_midi_event_get_compat( - jack_midi_event_t * event, - void * port_buffer, - jack_nframes_t event_index) -{ - return jack_midi_event_get(event, port_buffer, event_index, 0); -} - -#define jack_midi_event_get jack_midi_event_get_compat - -#else - -#if defined(HAVE_OLD_JACK_MIDI) -#error "Old (0.102.20) JACK MIDI API needs nframes (autotools probably gone mad)" -#endif - -#endif /* #if defined(JACK_MIDI_NEEDS_NFRAMES) */ - -#endif /* JACK_COMPAT_H */ diff --git a/src/engine/machina/Context.hpp b/src/engine/machina/Context.hpp index c863cc4..8f86602 100644 --- a/src/engine/machina/Context.hpp +++ b/src/engine/machina/Context.hpp @@ -26,7 +26,8 @@ namespace Machina { class MIDISink; -class Context { +class Context +{ public: Context(Raul::Forge& forge, uint32_t rate, uint32_t ppqn, double bpm) : _forge(forge) diff --git a/src/engine/machina/Controller.hpp b/src/engine/machina/Controller.hpp index f5bf631..ddd1d4c 100644 --- a/src/engine/machina/Controller.hpp +++ b/src/engine/machina/Controller.hpp @@ -30,7 +30,9 @@ #include "Stateful.hpp" -namespace Raul { class Atom; class Maid; } +namespace Raul { +class Atom; class Maid; +} namespace Machina { @@ -38,18 +40,25 @@ class Engine; class Machine; class Stateful; -namespace Client { class ClientModel; class ClientObject; } +namespace Client { +class ClientModel; class ClientObject; +} -class Controller { +class Controller +{ public: Controller(SharedPtr engine, Client::ClientModel& client_model); uint64_t create(const Client::ClientObject& obj); uint64_t connect(uint64_t tail_id, uint64_t head_id); - void set_property(uint64_t object_id, URIInt key, const Raul::Atom& value); - void learn(SharedPtr maid, uint64_t node_id); - void disconnect(uint64_t tail_id, uint64_t head_id); - void erase(uint64_t id); + + void set_property(uint64_t object_id, + URIInt key, + const Raul::Atom& value); + + void learn(SharedPtr maid, uint64_t node_id); + void disconnect(uint64_t tail_id, uint64_t head_id); + void erase(uint64_t id); void announce(SharedPtr machine); @@ -59,9 +68,11 @@ private: SharedPtr find(uint64_t id); struct StatefulComparator { - inline bool operator()(SharedPtr lhs, SharedPtr rhs) const { + inline bool operator()(SharedPtr lhs, + SharedPtr rhs) const { return lhs->id() < rhs->id(); } + }; typedef std::set, StatefulComparator> Objects; diff --git a/src/engine/machina/Driver.hpp b/src/engine/machina/Driver.hpp index 69bf951..778fd22 100644 --- a/src/engine/machina/Driver.hpp +++ b/src/engine/machina/Driver.hpp @@ -28,7 +28,9 @@ namespace Machina { class Machine; -class Driver : public MIDISink { +class Driver + : public MIDISink +{ public: Driver(Raul::Forge& forge, SharedPtr machine) : _forge(forge) @@ -38,23 +40,29 @@ public: virtual ~Driver() {} SharedPtr machine() { return _machine; } - virtual void set_machine(SharedPtr machine) { _machine = machine; } + + virtual void set_machine(SharedPtr machine) { + _machine = machine; + } SharedPtr update_sink() { return _updates; } - void set_update_sink(SharedPtr b) { _updates = b; } - virtual void set_bpm(double bpm) = 0; + void set_update_sink(SharedPtr b) { + _updates = b; + } + + virtual void set_bpm(double bpm) = 0; virtual void set_quantization(double q) = 0; virtual bool is_activated() const { return false; } - virtual void activate() {} - virtual void deactivate() {} + virtual void activate() {} + virtual void deactivate() {} virtual void stop() {} - virtual bool recording() { return false; } + virtual bool recording() { return false; } virtual void start_record(bool step) {} - virtual void finish_record() {} + virtual void finish_record() {} protected: Raul::Forge& _forge; diff --git a/src/engine/machina/Engine.hpp b/src/engine/machina/Engine.hpp index 5f11d55..7040082 100644 --- a/src/engine/machina/Engine.hpp +++ b/src/engine/machina/Engine.hpp @@ -32,7 +32,8 @@ namespace Machina { class Machine; -class Engine { +class Engine +{ public: Engine(Raul::Forge& forge, SharedPtr driver, diff --git a/src/engine/machina/Evolver.hpp b/src/engine/machina/Evolver.hpp index 8dd8e12..1aec3e8 100644 --- a/src/engine/machina/Evolver.hpp +++ b/src/engine/machina/Evolver.hpp @@ -25,16 +25,22 @@ #include "Schrodinbit.hpp" -namespace Eugene { template class HybridMutation; } +namespace Eugene { +template +class HybridMutation; +} namespace Machina { class Machine; class Problem; -class Evolver : public Raul::Thread { +class Evolver + : public Raul::Thread +{ public: - Evolver(Raul::TimeUnit unit, const string& target_midi, SharedPtr seed); + Evolver(Raul::TimeUnit unit, const string& target_midi, + SharedPtr seed); void seed(SharedPtr parent); bool improvement() { return _improvement; } diff --git a/src/engine/machina/Loader.hpp b/src/engine/machina/Loader.hpp index 470b109..f97618a 100644 --- a/src/engine/machina/Loader.hpp +++ b/src/engine/machina/Loader.hpp @@ -31,7 +31,8 @@ namespace Machina { class Machine; -class Loader { +class Loader +{ public: Loader(Raul::Forge& forge, Sord::World& rdf_world); diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp index 164c2e4..acfc599 100644 --- a/src/engine/machina/Machine.hpp +++ b/src/engine/machina/Machine.hpp @@ -41,7 +41,9 @@ class LearnRequest; /** A (Finite State) Machine. */ -class Machine : public Stateful { +class Machine + : public Stateful +{ public: Machine(TimeUnit unit); Machine(const Machine& copy); @@ -72,8 +74,8 @@ public: // Any context inline Raul::TimeStamp time() const { return _time; } - SharedPtr pending_learn() { return _pending_learn; } - void clear_pending_learn() { _pending_learn.reset(); } + SharedPtr pending_learn() { return _pending_learn; } + void clear_pending_learn() { _pending_learn.reset(); } typedef std::list< SharedPtr > Nodes; Nodes& nodes() { return _nodes; } @@ -85,10 +87,16 @@ public: private: // Audio context SharedPtr earliest_node() const; - bool enter_node(Context& context, SharedPtr node, SharedPtr updates); - void exit_node(Context& context, SharedPtr node, SharedPtr updates); - static const size_t MAX_ACTIVE_NODES = 128; + bool enter_node(Context& context, + SharedPtr node, + SharedPtr updates); + + void exit_node(Context& context, + SharedPtr node, + SharedPtr updates); + + static const size_t MAX_ACTIVE_NODES = 128; std::vector< SharedPtr > _active_nodes; SharedPtr _pending_learn; diff --git a/src/engine/machina/Mutation.hpp b/src/engine/machina/Mutation.hpp index 437165f..dd2dbbf 100644 --- a/src/engine/machina/Mutation.hpp +++ b/src/engine/machina/Mutation.hpp @@ -21,10 +21,10 @@ #include "machina_config.h" #ifdef HAVE_EUGENE - #include "eugene/Mutation.hpp" - #define SUPER : public Eugene::Mutation +# include "eugene/Mutation.hpp" +# define SUPER : public Eugene::Mutation #else - #define SUPER : public Mutation +# define SUPER : public Mutation #endif namespace Machina { @@ -33,7 +33,11 @@ class Machine; namespace Mutation { -struct Mutation { virtual ~Mutation() {}; virtual void mutate(Machine& machine) = 0; }; +struct Mutation { + virtual ~Mutation() {} + + virtual void mutate(Machine& machine) = 0; +}; struct Compress SUPER { void mutate(Machine& machine); }; struct AddNode SUPER { void mutate(Machine& machine); }; diff --git a/src/engine/machina/URIs.hpp b/src/engine/machina/URIs.hpp index 4838761..caed196 100644 --- a/src/engine/machina/URIs.hpp +++ b/src/engine/machina/URIs.hpp @@ -26,7 +26,8 @@ namespace Machina { -class URIs { +class URIs +{ public: static void init() { _instance = new URIs(); } diff --git a/src/engine/machina/types.hpp b/src/engine/machina/types.hpp index 8bae27a..7603d3c 100644 --- a/src/engine/machina/types.hpp +++ b/src/engine/machina/types.hpp @@ -24,7 +24,7 @@ namespace Machina { typedef unsigned char byte; -typedef Raul::RingBuffer UpdateBuffer; +typedef Raul::RingBuffer UpdateBuffer; typedef uint32_t URIInt; diff --git a/src/engine/quantize.hpp b/src/engine/quantize.hpp index 5d1b4f2..de4d20b 100644 --- a/src/engine/quantize.hpp +++ b/src/engine/quantize.hpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -37,8 +37,8 @@ inline double quantize(double q, double t) { return (q > 0) - ? lrint(t / q) * q - : t; + ? lrint(t / q) * q + : t; } } // namespace Machina diff --git a/src/engine/quantize_test.cpp b/src/engine/quantize_test.cpp index 2a2c11a..d690990 100644 --- a/src/engine/quantize_test.cpp +++ b/src/engine/quantize_test.cpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -30,12 +30,12 @@ main() TimeStamp beats(TimeUnit(TimeUnit::BEATS, 19200), in); /*cout << "Q(" << in << ", 1/4) = " - << quantize(q, beats) << endl;*/ + << quantize(q, beats) << endl;*/ - if (quantize(q, beats).subticks() % (19200/4) != 0) + if (quantize(q, beats).subticks() % (19200 / 4) != 0) { return 1; + } } return 0; } - diff --git a/src/engine/smf_test.cpp b/src/engine/smf_test.cpp index 4787b7d..ce0a7d6 100644 --- a/src/engine/smf_test.cpp +++ b/src/engine/smf_test.cpp @@ -1,5 +1,5 @@ /* - This file is part of Raul. + This file is part of Machina. Copyright 2007-2012 David Robillard Raul is free software: you can redistribute it and/or modify it under the @@ -28,9 +28,12 @@ main(int argc, char** argv) { #define CHECK(cond) \ do { if (!(cond)) { \ - error << "Test at " << __FILE__ << ":" << __LINE__ << " failed: " << __STRING(cond) << endl; \ - return 1; \ - } } while (0) + error << "Test at " << __FILE__ << ":" << __LINE__ \ + << " failed: " << __STRING(cond) << endl; \ + return 1; \ + } \ + } \ + while (0) static const uint16_t ppqn = 19200; @@ -46,7 +49,7 @@ main(int argc, char** argv) } SMFReader reader; - bool opened = reader.open(filename); + bool opened = reader.open(filename); if (!opened) { cerr << "Unable to open SMF file " << filename << endl; @@ -57,7 +60,7 @@ main(int argc, char** argv) CHECK(reader.num_tracks() == 1); CHECK(reader.ppqn() == ppqn); - for (unsigned t=1; t <= reader.num_tracks(); ++t) { + for (unsigned t = 1; t <= reader.num_tracks(); ++t) { reader.seek_to_track(t); unsigned char buf[4]; @@ -65,10 +68,11 @@ main(int argc, char** argv) uint32_t ev_delta_time; while (reader.read_event(4, buf, &ev_size, &ev_delta_time) >= 0) { - cout << t << ": Event, size = " << ev_size << ", time = " << ev_delta_time; + cout << t << ": Event, size = " << ev_size << ", time = " + << ev_delta_time; cout << ":\t"; cout.flags(ios::hex); - for (uint32_t i=0; i < ev_size; ++i) { + for (uint32_t i = 0; i < ev_size; ++i) { cout << "0x" << static_cast(buf[i]) << " "; } cout.flags(ios::dec); diff --git a/src/gui/EdgeView.cpp b/src/gui/EdgeView.cpp index 1853b08..afa8cfd 100644 --- a/src/gui/EdgeView.cpp +++ b/src/gui/EdgeView.cpp @@ -29,22 +29,22 @@ using Machina::URIs; /* probability colour stuff */ -#define RGB_TO_UINT(r,g,b) ((((guint)(r))<<16)|(((guint)(g))<<8)|((guint)(b))) -#define RGB_TO_RGBA(x,a) (((x) << 8) | ((((guint)a) & 0xff))) -#define RGBA_TO_UINT(r,g,b,a) RGB_TO_RGBA(RGB_TO_UINT(r,g,b), a) +#define RGB_TO_UINT(r, g, b) ((((guint)(r)) << 16) | (((guint)(g)) << 8) | ((guint)(b))) +#define RGB_TO_RGBA(x, a) (((x) << 8) | ((((guint)a) & 0xff))) +#define RGBA_TO_UINT(r, g, b, a) RGB_TO_RGBA(RGB_TO_UINT(r, g, b), a) -#define UINT_RGBA_R(x) (((uint32_t)(x))>>24) -#define UINT_RGBA_G(x) ((((uint32_t)(x))>>16)&0xff) -#define UINT_RGBA_B(x) ((((uint32_t)(x))>>8)&0xff) -#define UINT_RGBA_A(x) (((uint32_t)(x))&0xff) +#define UINT_RGBA_R(x) (((uint32_t)(x)) >> 24) +#define UINT_RGBA_G(x) ((((uint32_t)(x)) >> 16) & 0xff) +#define UINT_RGBA_B(x) ((((uint32_t)(x)) >> 8) & 0xff) +#define UINT_RGBA_A(x) (((uint32_t)(x)) & 0xff) -#define MONO_INTERPOLATE(v1, v2, t) ((int)rint((v2)*(t)+(v1)*(1-(t)))) +#define MONO_INTERPOLATE(v1, v2, t) ((int)rint((v2) * (t) + (v1) * (1 - (t)))) #define UINT_INTERPOLATE(c1, c2, t) \ - RGBA_TO_UINT( MONO_INTERPOLATE(UINT_RGBA_R(c1), UINT_RGBA_R(c2), t), \ - MONO_INTERPOLATE(UINT_RGBA_G(c1), UINT_RGBA_G(c2), t), \ - MONO_INTERPOLATE(UINT_RGBA_B(c1), UINT_RGBA_B(c2), t), \ - MONO_INTERPOLATE(UINT_RGBA_A(c1), UINT_RGBA_A(c2), t) ) + RGBA_TO_UINT(MONO_INTERPOLATE(UINT_RGBA_R(c1), UINT_RGBA_R(c2), t), \ + MONO_INTERPOLATE(UINT_RGBA_G(c1), UINT_RGBA_G(c2), t), \ + MONO_INTERPOLATE(UINT_RGBA_B(c1), UINT_RGBA_B(c2), t), \ + MONO_INTERPOLATE(UINT_RGBA_A(c1), UINT_RGBA_A(c2), t) ) inline static uint32_t edge_color(float prob) { @@ -52,10 +52,11 @@ inline static uint32_t edge_color(float prob) static const uint32_t mid = 0xFFFF44C0; static const uint32_t max = 0x44FF44C0; - if (prob <= 0.5) - return UINT_INTERPOLATE(min, mid, prob*2.0); - else - return UINT_INTERPOLATE(mid, max, (prob-0.5)*2.0); + if (prob <= 0.5) { + return UINT_INTERPOLATE(min, mid, prob * 2.0); + } else { + return UINT_INTERPOLATE(mid, max, (prob - 0.5) * 2.0); + } } /* end probability colour stuff */ @@ -88,7 +89,8 @@ double EdgeView::length_hint() const { NodeView* tail = dynamic_cast(get_tail()); - return tail->node()->get(URIs::instance().machina_duration).get_float() * 10.0; + return tail->node()->get(URIs::instance().machina_duration).get_float() + * 10.0; } void @@ -126,6 +128,7 @@ EdgeView::on_event(GdkEvent* ev) void EdgeView::on_property(Machina::URIInt key, const Raul::Atom& value) { - if (key == URIs::instance().machina_probability) + if (key == URIs::instance().machina_probability) { set_color(edge_color(value.get_float())); + } } diff --git a/src/gui/EdgeView.hpp b/src/gui/EdgeView.hpp index bb9b478..b532071 100644 --- a/src/gui/EdgeView.hpp +++ b/src/gui/EdgeView.hpp @@ -28,7 +28,8 @@ class NodeView; class EdgeView : public Ganv::Edge - , public Machina::Client::ClientObject::View { + , public Machina::Client::ClientObject::View +{ public: EdgeView(Ganv::Canvas& canvas, SharedPtr src, diff --git a/src/gui/MachinaCanvas.cpp b/src/gui/MachinaCanvas.cpp index a2bb2ac..3d01012 100644 --- a/src/gui/MachinaCanvas.cpp +++ b/src/gui/MachinaCanvas.cpp @@ -41,32 +41,37 @@ MachinaCanvas::MachinaCanvas(MachinaGUI* app, int width, int height) widget().grab_focus(); signal_event.connect( - sigc::mem_fun(this, &MachinaCanvas::on_event)); + sigc::mem_fun(this, &MachinaCanvas::on_event)); } bool MachinaCanvas::node_clicked(WeakPtr item, GdkEventButton* event) { SharedPtr node = PtrCast(item.lock()); - if (!node) + if (!node) { return false; + } - if (event->state & GDK_CONTROL_MASK) + if (event->state & GDK_CONTROL_MASK) { return false; + } - if (event->button == 2) { // Middle click: learn + if (event->button == 2) { + // Middle click: learn _app->controller()->learn(_app->maid(), node->node()->id()); return false; - } else if (event->button == 1) { // Left click: connect/disconnect + } else if (event->button == 1) { + // Left click: connect/disconnect SharedPtr last = _last_clicked.lock(); if (last) { if (node != last) { - if (get_edge(last.get(), node.get())) + if (get_edge(last.get(), node.get())) { action_disconnect(last, node); - else + } else { action_connect(last, node); + } } last->set_default_colors(); @@ -85,9 +90,9 @@ MachinaCanvas::node_clicked(WeakPtr item, GdkEventButton* event) bool MachinaCanvas::on_event(GdkEvent* event) { - if (event->type == GDK_BUTTON_RELEASE - && event->button.button == 3 - && !(event->button.state & (GDK_CONTROL_MASK))) { + if (( event->type == GDK_BUTTON_RELEASE) + && ( event->button.button == 3) + && !(event->button.state & (GDK_CONTROL_MASK))) { action_create_node(event->button.x, event->button.y); return true; @@ -110,16 +115,18 @@ MachinaCanvas::on_new_object(SharedPtr object) // view->set_base_color(0x101010FF); view->signal_clicked().connect( - sigc::bind<0>(sigc::mem_fun(this, &MachinaCanvas::node_clicked), - WeakPtr(view))); + sigc::bind<0>(sigc::mem_fun(this, &MachinaCanvas::node_clicked), + WeakPtr(view))); object->set_view(view); } else if (type.get() == uris.machina_Edge) { - SharedPtr tail = _app->client_model()->find( - object->get(uris.machina_tail_id).get_int32()); - SharedPtr head = _app->client_model()->find( - object->get(uris.machina_head_id).get_int32()); + SharedPtr tail + = _app->client_model()->find( + object->get(uris.machina_tail_id).get_int32()); + SharedPtr head + = _app->client_model()->find( + object->get(uris.machina_head_id).get_int32()); if (!tail || !head) { std::cerr << "Invalid arc" << std::endl; diff --git a/src/gui/MachinaCanvas.hpp b/src/gui/MachinaCanvas.hpp index 7a80d33..4f190fd 100644 --- a/src/gui/MachinaCanvas.hpp +++ b/src/gui/MachinaCanvas.hpp @@ -28,9 +28,14 @@ using namespace Ganv; class MachinaGUI; class NodeView; -namespace Machina { namespace Client { class ClientObject; } } - -class MachinaCanvas : public Canvas +namespace Machina { +namespace Client { +class ClientObject; +} +} + +class MachinaCanvas + : public Canvas { public: MachinaCanvas(MachinaGUI* app, int width, int height); diff --git a/src/gui/MachinaGUI.cpp b/src/gui/MachinaGUI.cpp index 1a92d40..6e3b188 100644 --- a/src/gui/MachinaGUI.cpp +++ b/src/gui/MachinaGUI.cpp @@ -49,7 +49,8 @@ MachinaGUI::MachinaGUI(SharedPtr engine) , _controller(new Machina::Controller(_engine, *_client_model.get())) , _maid(new Raul::Maid()) { - _canvas = boost::shared_ptr(new MachinaCanvas(this, 1600*2, 1200*2)); + _canvas = boost::shared_ptr( + new MachinaCanvas(this, 1600*2, 1200*2)); Glib::RefPtr xml = WidgetFactory::create(); @@ -96,15 +97,16 @@ MachinaGUI::MachinaGUI(SharedPtr engine) _canvas_scrolledwindow->add(_canvas->widget()); _canvas_scrolledwindow->signal_event().connect(sigc::mem_fun(this, &MachinaGUI::scrolled_window_event)); - _canvas->scroll_to(static_cast(_canvas->get_width()/2.0 - 320), - static_cast(_canvas->get_height()/2.0 - 240)); // FIXME: hardcoded _canvas_scrolledwindow->property_hadjustment().get_value()->set_step_increment(10); _canvas_scrolledwindow->property_vadjustment().get_value()->set_step_increment(10); - _record_button->signal_toggled().connect(sigc::mem_fun(this, &MachinaGUI::record_toggled)); - _stop_button->signal_clicked().connect(sigc::mem_fun(this, &MachinaGUI::stop_clicked)); - _play_button->signal_toggled().connect(sigc::mem_fun(this, &MachinaGUI::play_toggled)); + _record_button->signal_toggled().connect( + sigc::mem_fun(this, &MachinaGUI::record_toggled)); + _stop_button->signal_clicked().connect( + sigc::mem_fun(this, &MachinaGUI::stop_clicked)); + _play_button->signal_toggled().connect( + sigc::mem_fun(this, &MachinaGUI::play_toggled)); _zoom_normal_button->signal_clicked().connect(sigc::bind( sigc::mem_fun(this, &MachinaGUI::zoom), 1.0)); @@ -145,7 +147,8 @@ MachinaGUI::MachinaGUI(SharedPtr engine) sigc::mem_fun(this, &MachinaGUI::quantize_changed)); _mutate_button->signal_clicked().connect(sigc::bind( - sigc::mem_fun(this, &MachinaGUI::random_mutation), SharedPtr())); + sigc::mem_fun(this, &MachinaGUI::random_mutation), + SharedPtr())); _compress_button->signal_clicked().connect(sigc::hide_return(sigc::bind( sigc::mem_fun(this, &MachinaGUI::mutate), SharedPtr(), 0))); _add_node_button->signal_clicked().connect(sigc::bind( @@ -180,12 +183,16 @@ MachinaGUI::MachinaGUI(SharedPtr engine) 1000); // Idle callback to update node states - Glib::signal_timeout().connect(sigc::mem_fun(this, &MachinaGUI::idle_callback), 100); + Glib::signal_timeout().connect( + sigc::mem_fun(this, &MachinaGUI::idle_callback), 100); #ifdef HAVE_EUGENE - _load_target_button->signal_clicked().connect(sigc::mem_fun(this, &MachinaGUI::load_target_clicked)); - _evolve_button->signal_clicked().connect(sigc::mem_fun(this, &MachinaGUI::evolve_toggled)); - Glib::signal_timeout().connect(sigc::mem_fun(this, &MachinaGUI::evolve_callback), 1000); + _load_target_button->signal_clicked().connect( + sigc::mem_fun(this, &MachinaGUI::load_target_clicked)); + _evolve_button->signal_clicked().connect( + sigc::mem_fun(this, &MachinaGUI::evolve_toggled)); + Glib::signal_timeout().connect( + sigc::mem_fun(this, &MachinaGUI::evolve_callback), 1000); #else _evolve_toolbar->set_sensitive(false); #endif @@ -193,8 +200,10 @@ MachinaGUI::MachinaGUI(SharedPtr engine) _controller->announce(engine->machine()); _canvas->arrange(); - _client_model->signal_new_object.connect(sigc::mem_fun(this, &MachinaGUI::on_new_object)); - _client_model->signal_erase_object.connect(sigc::mem_fun(this, &MachinaGUI::on_erase_object)); + _client_model->signal_new_object.connect( + sigc::mem_fun(this, &MachinaGUI::on_new_object)); + _client_model->signal_erase_object.connect( + sigc::mem_fun(this, &MachinaGUI::on_erase_object)); } MachinaGUI::~MachinaGUI() @@ -280,7 +289,8 @@ void MachinaGUI::evolve_toggled() { if (_evolve_button->get_active()) { - _evolver = SharedPtr(new Evolver(_unit, _target_filename, _engine->machine())); + _evolver = SharedPtr( + new Evolver(_unit, _target_filename, _engine->machine())); _evolve = true; stop_clicked(); _engine->driver()->set_machine(SharedPtr()); @@ -288,7 +298,8 @@ MachinaGUI::evolve_toggled() } else { _evolver->stop(); _evolve = false; - SharedPtr new_machine = SharedPtr(new Machine(*_evolver->best())); + SharedPtr new_machine = SharedPtr( + new Machine(*_evolver->best())); _engine->driver()->set_machine(new_machine); _canvas->build(new_machine, _menu_view_labels->get_active()); new_machine->activate(); diff --git a/src/gui/MachinaGUI.hpp b/src/gui/MachinaGUI.hpp index 27133e0..c48ac93 100644 --- a/src/gui/MachinaGUI.hpp +++ b/src/gui/MachinaGUI.hpp @@ -35,7 +35,9 @@ class Machine; class Engine; class Evolver; class Controller; -namespace Client { class ClientModel; class ClientObject; } +namespace Client { +class ClientModel; class ClientObject; +} } class MachinaCanvas; @@ -65,7 +67,9 @@ public: void on_new_object(SharedPtr object); void on_erase_object(SharedPtr object); - SharedPtr client_model() { return _client_model; } + SharedPtr client_model() { + return _client_model; + } protected: void connect_widgets(); diff --git a/src/gui/NodePropertiesWindow.cpp b/src/gui/NodePropertiesWindow.cpp index 90e1269..52ad5af 100644 --- a/src/gui/NodePropertiesWindow.cpp +++ b/src/gui/NodePropertiesWindow.cpp @@ -24,8 +24,9 @@ using namespace Machina; NodePropertiesWindow* NodePropertiesWindow::_instance = NULL; -NodePropertiesWindow::NodePropertiesWindow(BaseObjectType* cobject, - const Glib::RefPtr& xml) +NodePropertiesWindow::NodePropertiesWindow( + BaseObjectType* cobject, + const Glib::RefPtr& xml) : Gtk::Dialog(cobject) { property_visible() = false; @@ -45,13 +46,12 @@ NodePropertiesWindow::NodePropertiesWindow(BaseObjectType* cob } NodePropertiesWindow::~NodePropertiesWindow() -{ -} +{} void NodePropertiesWindow::apply_clicked() { - #if 0 +#if 0 const uint8_t note = _note_spinbutton->get_value(); if (!_node->enter_action()) { _node->set_enter_action(ActionFactory::note_on(note)); @@ -59,15 +59,15 @@ NodePropertiesWindow::apply_clicked() } else { SharedPtr action = PtrCast(_node->enter_action()); action->event()[1] = note; - action = PtrCast(_node->exit_action()); + action = PtrCast(_node->exit_action()); action->event()[1] = note; } const double duration_dbl = _duration_spinbutton->get_value(); - TimeStamp duration(TimeUnit(TimeUnit::BEATS, 19200), duration_dbl); + TimeStamp duration(TimeUnit(TimeUnit::BEATS, 19200), duration_dbl); _node->set_duration(duration); _node->set_changed(); - #endif +#endif } void @@ -89,10 +89,10 @@ void NodePropertiesWindow::set_node(SharedPtr node) { _node = node; - #if 0 +#if 0 SharedPtr enter_action = PtrCast(node->enter_action()); - if (enter_action && enter_action->event_size() > 1 - && (enter_action->event()[0] & 0xF0) == 0x90) { + if (enter_action && ( enter_action->event_size() > 1) + && ( (enter_action->event()[0] & 0xF0) == 0x90) ) { _note_spinbutton->set_value(enter_action->event()[1]); _note_spinbutton->show(); } else if (!enter_action) { @@ -102,22 +102,23 @@ NodePropertiesWindow::set_node(SharedPtr node) _note_spinbutton->hide(); } _duration_spinbutton->set_value(node->duration().to_double()); - #endif +#endif } void -NodePropertiesWindow::present(Gtk::Window* parent, SharedPtr node) +NodePropertiesWindow::present(Gtk::Window* parent, + SharedPtr node) { if (!_instance) { Glib::RefPtr xml = WidgetFactory::create(); xml->get_widget_derived("node_properties_dialog", _instance); - if (parent) + if (parent) { _instance->set_transient_for(*parent); + } } _instance->set_node(node); _instance->show(); } - diff --git a/src/gui/NodePropertiesWindow.hpp b/src/gui/NodePropertiesWindow.hpp index 2b61d03..7d395c9 100644 --- a/src/gui/NodePropertiesWindow.hpp +++ b/src/gui/NodePropertiesWindow.hpp @@ -22,12 +22,17 @@ #include "raul/SharedPtr.hpp" -namespace Machina { namespace Client { class ClientObject; } } - -class NodePropertiesWindow : public Gtk::Dialog +namespace Machina { +namespace Client { +class ClientObject; +} +} + +class NodePropertiesWindow + : public Gtk::Dialog { public: - NodePropertiesWindow(BaseObjectType* cobject, + NodePropertiesWindow(BaseObjectType* cobject, const Glib::RefPtr& xml); ~NodePropertiesWindow(); diff --git a/src/gui/NodeView.cpp b/src/gui/NodeView.cpp index d388921..c1eeff0 100644 --- a/src/gui/NodeView.cpp +++ b/src/gui/NodeView.cpp @@ -78,7 +78,8 @@ NodeView::on_event(GdkEvent* event) canvas->app()->controller()->set_property( _node->id(), URIs::instance().machina_selector, - forge.make(!node_is(forge, URIs::instance().machina_selector))); + forge.make(!node_is(forge, + URIs::instance().machina_selector))); return true; } } else { @@ -93,7 +94,9 @@ NodeView::on_event(GdkEvent* event) static std::string midi_note_name(uint8_t num) { - static const char* notes[] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B"}; + static const char* notes[] = { + "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" + }; const uint8_t octave = num / 12; num -= octave * 12; @@ -107,7 +110,8 @@ void NodeView::show_label(bool show) { if (show && _enter_action) { - Raul::Atom note_number = _enter_action->get(URIs::instance().machina_note_number); + Raul::Atom note_number = _enter_action->get( + URIs::instance().machina_note_number); if (note_number.is_valid()) { set_label(midi_note_name(note_number.get_int32()).c_str()); return; @@ -148,7 +152,7 @@ NodeView::on_property(Machina::URIInt key, const Raul::Atom& value) } } else if (key == URIs::instance().machina_enter_action) { const uint64_t action_id = value.get_int32(); - MachinaCanvas* canvas = dynamic_cast(this->canvas()); + MachinaCanvas* canvas = dynamic_cast(this->canvas()); _enter_action_connection.disconnect(); _enter_action = canvas->app()->client_model()->find(action_id); if (_enter_action) { diff --git a/src/gui/NodeView.hpp b/src/gui/NodeView.hpp index 61e4838..5359b4b 100644 --- a/src/gui/NodeView.hpp +++ b/src/gui/NodeView.hpp @@ -26,7 +26,8 @@ class NodeView : public Ganv::Circle - , public Machina::Client::ClientObject::View { + , public Machina::Client::ClientObject::View +{ public: NodeView(Gtk::Window* window, Canvas& canvas, diff --git a/src/gui/WidgetFactory.hpp b/src/gui/WidgetFactory.hpp index 6d706dd..41e8200 100644 --- a/src/gui/WidgetFactory.hpp +++ b/src/gui/WidgetFactory.hpp @@ -30,17 +30,18 @@ public: Glib::RefPtr xml; // Check for the .ui file in current directory - std::string ui_filename = "./machina.ui"; + std::string ui_filename = "./machina.ui"; std::ifstream fs(ui_filename.c_str()); - if (fs.fail()) { // didn't find it, check MACHINA_DATA_DIR + if (fs.fail()) { + // didn't find it, check MACHINA_DATA_DIR fs.clear(); - ui_filename = MACHINA_DATA_DIR; + ui_filename = MACHINA_DATA_DIR; ui_filename += "/machina.ui"; fs.open(ui_filename.c_str()); if (fs.fail()) { - std::cerr << "Unable to find machina.ui in current directory or " - << MACHINA_DATA_DIR << "." << std::endl; + std::cerr << "No machina.ui in current directory or " + << MACHINA_DATA_DIR << "." << std::endl; exit(EXIT_FAILURE); } fs.close(); @@ -48,12 +49,12 @@ public: try { xml = Gtk::Builder::create_from_file(ui_filename); - } catch(const Gtk::BuilderError& ex) { + } catch (const Gtk::BuilderError& ex) { std::cerr << ex.what() << std::endl; throw ex; } return xml; } -}; +}; diff --git a/src/gui/main.cpp b/src/gui/main.cpp index 7a70250..e87e29d 100644 --- a/src/gui/main.cpp +++ b/src/gui/main.cpp @@ -32,8 +32,9 @@ using namespace Machina; int main(int argc, char** argv) { - if ( ! Glib::thread_supported()) + if (!Glib::thread_supported()) { Glib::thread_init(); + } Sord::World rdf_world; @@ -58,7 +59,7 @@ main(int argc, char** argv) } if (!machine) { - cout << "Not a MIDI file. Attempting to load as Machina file." << endl; + cout << "Not MIDI, attempting to load machine" << endl; machine = Loader(rdf_world).load(filename); } } @@ -66,14 +67,15 @@ main(int argc, char** argv) Raul::Forge forge; - if (!machine) + if (!machine) { machine = SharedPtr( - new Machine(TimeUnit(TimeUnit::BEATS, 19200))); + new Machine(TimeUnit(TimeUnit::BEATS, 19200))); + } std::string driver_name = "smf"; - #ifdef HAVE_JACK + #ifdef HAVE_JACK driver_name = "jack"; - #endif + #endif // Build engine SharedPtr driver(Engine::new_driver(forge, driver_name, machine)); @@ -88,4 +90,3 @@ main(int argc, char** argv) return 0; } - diff --git a/src/machina.cpp b/src/machina.cpp index 35ba7f1..4dc9ada 100644 --- a/src/machina.cpp +++ b/src/machina.cpp @@ -25,7 +25,7 @@ #include "machina/Machine.hpp" #include "machina/MidiAction.hpp" #ifdef HAVE_EUGENE - #include "machina/Problem.hpp" +# include "machina/Problem.hpp" #endif #include "JackDriver.hpp" @@ -54,21 +54,22 @@ main(int argc, char** argv) return -1; } - if ( ! Glib::thread_supported()) + if (!Glib::thread_supported()) { Glib::thread_init(); + } SharedPtr driver(new JackDriver()); Sord::World rdf_world; - Engine engine(driver, rdf_world); + Engine engine(driver, rdf_world); /* FIXME: Would be nice if this could take URIs on the cmd line - char* uri = (char*)calloc(6 + strlen(argv[1]), sizeof(char)); - strcpy(uri, "file:"); - strcat(uri, argv[1]); - engine.load_machine(uri); - free(uri); - */ + char* uri = (char*)calloc(6 + strlen(argv[1]), sizeof(char)); + strcpy(uri, "file:"); + strcat(uri, argv[1]); + engine.load_machine(uri); + free(uri); + */ engine.load_machine(argv[1]); driver->attach("machina"); @@ -76,11 +77,11 @@ main(int argc, char** argv) signal(SIGINT, catch_int); signal(SIGTERM, catch_int); - while (!quit) + while (!quit) { sleep(1); + } driver->detach(); return 0; } - diff --git a/src/midi2machina.cpp b/src/midi2machina.cpp index 5918e5c..3a7f055 100644 --- a/src/midi2machina.cpp +++ b/src/midi2machina.cpp @@ -46,7 +46,8 @@ main(int argc, char** argv) { if (argc != 3) { cout << "Usage: midi2machina QUANTIZATION FILE" << endl; - cout << "Specify quantization in beats, e.g. 1.0, or 0 for none" << endl; + cout << "Specify quantization in beats, e.g. 1.0, or 0 for none" + << endl; return -1; } @@ -60,17 +61,17 @@ main(int argc, char** argv) } /* - string out_filename = argv[1]; - if (out_filename.find_last_of("/") != string::npos) - out_filename = out_filename.substr(out_filename.find_last_of("/")+1); + string out_filename = argv[1]; + if (out_filename.find_last_of("/") != string::npos) + out_filename = out_filename.substr(out_filename.find_last_of("/")+1); - const string::size_type last_dot = out_filename.find_last_of("."); - if (last_dot != string::npos && last_dot != 0) - out_filename = out_filename.substr(0, last_dot); - out_filename += ".machina"; + const string::size_type last_dot = out_filename.find_last_of("."); + if (last_dot != string::npos && last_dot != 0) + out_filename = out_filename.substr(0, last_dot); + out_filename += ".machina"; - cout << "Writing output to " << out_filename << endl; - */ + cout << "Writing output to " << out_filename << endl; + */ Sord::World world; Sord::Model model(world); @@ -79,4 +80,3 @@ main(int argc, char** argv) return 0; } - -- cgit v1.2.1