Bulk reformat.

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

1 files changed, 97 insertions, 60 deletions

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> 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<Machine>(
-				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> machine)
 {
-	if (machine == _machine)
+	if (machine == _machine) {
 		return;
+	}
 
 	SharedPtr<Machine> 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> machine, const Raul::TimeSlice& time)
+JackDriver::process_input(SharedPtr<Machine>     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> 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> 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> 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<Recorder>(new Recorder(_forge, 1024, _beats_unit, _quantization.get(), step));
+	_recorder
+	    = SharedPtr<Recorder>(new Recorder(_forge, 1024, _beats_unit,
+	                                       _quantization.get(), step));
 	_recorder->start();
 	_record_dur = 0;
-	_recording = true;
+	_recording  = true;
 }
 
 void