Move run context information to Context object and remove Machine::_forge.

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

1 files changed, 55 insertions, 53 deletions

diff --git a/src/engine/JackDriver.cpp b/src/engine/JackDriver.cpp
index bcde9ef..bc1e38e 100644
--- a/src/engine/JackDriver.cpp
+++ b/src/engine/JackDriver.cpp
@@ -18,9 +18,10 @@
 #include <iostream>
 #include <iomanip>
 
-#include "machina_config.h"
+#include "machina/Context.hpp"
 #include "machina/URIs.hpp"
 #include "machina/Updates.hpp"
+#include "machina_config.h"
 
 #include "JackDriver.hpp"
 #include "LearnRequest.hpp"
@@ -38,9 +39,9 @@ JackDriver::JackDriver(Raul::Forge& forge, SharedPtr<Machine> machine)
 	, _machine_changed(0)
 	, _input_port(NULL)
 	, _output_port(NULL)
+	, _context(forge, 48000, MACHINA_PPQN, 120.0)
 	, _frames_unit(TimeUnit::FRAMES, 48000)
 	, _beats_unit(TimeUnit::BEATS, 19200)
-	, _cycle_time(48000, MACHINA_PPQN, 120.0)
 	, _bpm(120.0)
 	, _quantization(0.0f)
 	, _stop(0)
@@ -77,28 +78,27 @@ JackDriver::attach(const std::string& client_name)
 
 	if (jack_client()) {
 
-		//_cycle_time.set_tick_rate(1/(double)sample_rate());
+		_context.time().set_tick_rate(sample_rate());
 
 		_input_port = jack_port_register(jack_client(),
-			"in",
-			JACK_DEFAULT_MIDI_TYPE, JackPortIsInput,
-			0);
+		                                 "in",
+		                                 JACK_DEFAULT_MIDI_TYPE, JackPortIsInput,
+		                                 0);
 
 		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);
+		                                  "out",
+		                                  JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput,
+		                                  0);
 
 		if (!_output_port)
 			std::cerr << "WARNING: Failed to create MIDI output port." << std::endl;
 
 		if (!_machine)
 			_machine = SharedPtr<Machine>(
-				new Machine(_forge,
-				            TimeUnit::frames(jack_get_sample_rate(jack_client()))));
+				new Machine(TimeUnit::frames(jack_get_sample_rate(jack_client()))));
 
 		_machine->activate();
 	}
@@ -205,8 +205,8 @@ JackDriver::process_input(SharedPtr<Machine> machine, const Raul::TimeSlice& tim
 				if (learn) {
 					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));
+					             TimeStamp(TimeUnit::frames(sample_rate()),
+					                       jack_last_frame_time(_client) + ev.time, 0));
 				}
 
 			} else if (ev.buffer[0] == 0x80) {
@@ -218,7 +218,7 @@ JackDriver::process_input(SharedPtr<Machine> machine, const Raul::TimeSlice& tim
 						learn->exit_action()->set_event(ev.size, ev.buffer);
 						learn->finish(
 							TimeStamp(TimeUnit::frames(sample_rate()),
-								jack_last_frame_time(_client) + ev.time, 0));
+							          jack_last_frame_time(_client) + ev.time, 0));
 
 						const uint64_t id = Stateful::next_id();
 						write_set(_updates, id,
@@ -248,39 +248,41 @@ JackDriver::write_event(Raul::TimeStamp time,
 	if (!_output_port)
 		return;
 
-	if (_cycle_time.beats_to_ticks(time) + _cycle_time.offset_ticks() < _cycle_time.start_ticks()) {
+	const Raul::TimeSlice& slice = _context.time();
+
+	if (slice.beats_to_ticks(time) + slice.offset_ticks() < slice.start_ticks()) {
 		std::cerr << "ERROR: Missed event by "
-			<< _cycle_time.start_ticks()
-				- (_cycle_time.beats_to_ticks(time) + _cycle_time.offset_ticks())
-			<< " ticks"
-			<< "\n\tbpm: " << _cycle_time.bpm()
-			<< "\n\tev time: " << _cycle_time.beats_to_ticks(time)
-			<< "\n\tcycle_start: " << _cycle_time.start_ticks()
-			<< "\n\tcycle_end: " << _cycle_time.start_ticks() + _cycle_time.length_ticks()
-			<< "\n\tcycle_length: " << _cycle_time.length_ticks() << std::endl << std::endl;
+		          << slice.start_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;
 		return;
 	}
 
-	const TimeDuration nframes = _cycle_time.length_ticks();
-	const TimeStamp    offset  = _cycle_time.beats_to_ticks(time)
-		+ _cycle_time.offset_ticks() - _cycle_time.start_ticks();
+	const TimeDuration nframes = slice.length_ticks();
+	const TimeStamp    offset  = slice.beats_to_ticks(time)
+		+ slice.offset_ticks() - slice.start_ticks();
 
-	if ( ! (offset < _cycle_time.offset_ticks() + nframes)) {
+	if ( ! (offset < slice.offset_ticks() + nframes)) {
 		std::cerr << "ERROR: Event offset " << offset << " outside cycle "
-			<< "\n\tbpm: " << _cycle_time.bpm()
-			<< "\n\tev time: " << _cycle_time.beats_to_ticks(time)
-			<< "\n\tcycle_start: " << _cycle_time.start_ticks()
-			<< "\n\tcycle_end: " << _cycle_time.start_ticks() + _cycle_time.length_ticks()
-			<< "\n\tcycle_length: " << _cycle_time.length_ticks() << std::endl;
+		          << "\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;
 	} 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
 	}
 }
@@ -288,7 +290,7 @@ JackDriver::write_event(Raul::TimeStamp time,
 void
 JackDriver::on_process(jack_nframes_t nframes)
 {
-	_cycle_time.set_bpm(_bpm.get());
+	_context.time().set_bpm(_bpm.get());
 
 	assert(_output_port);
 #ifdef JACK_MIDI_NEEDS_NFRAMES
@@ -297,11 +299,11 @@ JackDriver::on_process(jack_nframes_t nframes)
 	jack_midi_clear_buffer(jack_port_get_buffer(_output_port, nframes));
 #endif
 
-	TimeStamp length_ticks(TimeStamp(_cycle_time.ticks_unit(), nframes));
-	TimeStamp length_beats(_cycle_time.ticks_to_beats(length_ticks));
+	TimeStamp length_ticks(TimeStamp(_context.time().ticks_unit(), nframes));
+	TimeStamp length_beats(_context.time().ticks_to_beats(length_ticks));
 
-	_cycle_time.set_length(length_ticks);
-	_cycle_time.set_offset(TimeStamp(_cycle_time.ticks_unit(), 0, 0));
+	_context.time().set_length(length_ticks);
+	_context.time().set_offset(TimeStamp(_context.time().ticks_unit(), 0, 0));
 
 	/* Take a reference to machine here and use only it during the process
 	 * cycle so _machine can be switched with set_machine during a cycle. */
@@ -326,35 +328,35 @@ JackDriver::on_process(jack_nframes_t nframes)
 	machine->set_sink(shared_from_this());
 
 	if (_stop_flag)
-		machine->reset(_cycle_time.start_beats());
+		machine->reset(_context.time().start_beats());
 
-	process_input(machine, _cycle_time);
+	process_input(machine, _context.time());
 
 	if (machine->is_empty() || !machine->is_activated())
 		goto end;
 
 	while (true) {
-		const uint32_t run_dur_frames = machine->run(_cycle_time, _updates);
+		const uint32_t run_dur_frames = machine->run(_context, _updates);
 
 		if (run_dur_frames == 0) {
 			// Machine didn't run at all (machine has no initial states)
 			machine->reset(machine->time()); // Try again next cycle
-			_cycle_time.set_slice(TimeStamp(_frames_unit, 0, 0),
-			                      TimeStamp(_frames_unit, 0, 0));
+			_context.time().set_slice(TimeStamp(_frames_unit, 0, 0),
+			                          TimeStamp(_frames_unit, 0, 0));
 			break;
 
 		} else if (machine->is_finished()) {
 			// Machine ran for portion of cycle and is finished
 			machine->reset(machine->time());
 
-			_cycle_time.set_slice(TimeStamp(_frames_unit, 0, 0),
-			                      TimeStamp(_frames_unit, nframes - run_dur_frames, 0));
-			_cycle_time.set_offset(TimeStamp(_frames_unit, run_dur_frames, 0));
+			_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));
 
 		} else {
 			// Machine ran for entire cycle
-			_cycle_time.set_slice(
-				_cycle_time.start_ticks() + _cycle_time.length_ticks(),
+			_context.time().set_slice(
+				_context.time().start_ticks() + _context.time().length_ticks(),
 				TimeStamp(_frames_unit, 0, 0));
 			break;
 		}
@@ -366,8 +368,8 @@ end:
 	_last_machine = machine;
 
 	if (_stop_flag) {
-		_cycle_time.set_slice(TimeStamp(_frames_unit, 0, 0),
-		                      TimeStamp(_frames_unit, 0, 0));
+		_context.time().set_slice(TimeStamp(_frames_unit, 0, 0),
+		                          TimeStamp(_frames_unit, 0, 0));
 		_stop_flag = false;
 	}
 }