Use Raul::TimeStamp (LV2 compatible typed 32:32 fixed timestamp) everywhere.

Fix initial size of Patchage messages window.
Machina disabled for now (transitioning to generic timestamps).


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

11 files changed, 64 insertions, 64 deletions

diff --git a/src/engine/machina/Action.hpp b/src/engine/machina/Action.hpp
index 3cab3ee..1d1700d 100644
--- a/src/engine/machina/Action.hpp
+++ b/src/engine/machina/Action.hpp
@@ -32,7 +32,7 @@ namespace Machina {
 /** An Action, executed on entering or exiting of a state.
  */
 struct Action : public Raul::Deletable, public Raul::Stateful {
-	virtual void execute(SharedPtr<Raul::MIDISink> sink, Raul::BeatTime time) = 0;
+	virtual void execute(SharedPtr<Raul::MIDISink> sink, Raul::TimeStamp time) = 0;
 
 	virtual void write_state(Redland::Model& model);
 };
@@ -42,7 +42,7 @@ class PrintAction : public Action {
 public:
 	PrintAction(const std::string& msg) : _msg(msg) {}
 
-	void execute(SharedPtr<Raul::MIDISink>, Raul::BeatTime time)
+	void execute(SharedPtr<Raul::MIDISink>, Raul::TimeStamp time)
 	{ std::cout << "t=" << time << ": " << _msg << std::endl; }
 
 private:
diff --git a/src/engine/machina/Driver.hpp b/src/engine/machina/Driver.hpp
index e497356..31d8a9c 100644
--- a/src/engine/machina/Driver.hpp
+++ b/src/engine/machina/Driver.hpp
@@ -34,7 +34,7 @@ public:
 	virtual void set_machine(SharedPtr<Machine> machine) { _machine = machine; }
 	
 	virtual void set_bpm(double bpm) = 0;
-	virtual void set_quantization(double quantization) = 0;
+	virtual void set_quantization(Raul::TimeStamp q) = 0;
 	
 	virtual void activate() {}
 	virtual void deactivate() {}
diff --git a/src/engine/machina/Engine.hpp b/src/engine/machina/Engine.hpp
index effa4be..763b9a8 100644
--- a/src/engine/machina/Engine.hpp
+++ b/src/engine/machina/Engine.hpp
@@ -20,7 +20,6 @@
 
 #include <glibmm/ustring.h>
 #include <raul/SharedPtr.hpp>
-#include <raul/types.hpp>
 #include "machina/Driver.hpp"
 #include "machina/Loader.hpp"
 
@@ -45,7 +44,7 @@ public:
 
 	SharedPtr<Machine> load_machine(const Glib::ustring& uri);
 	SharedPtr<Machine> import_machine(const Glib::ustring& uri);
-	SharedPtr<Machine> import_midi(const Glib::ustring& uri, Raul::BeatTime d);
+	SharedPtr<Machine> import_midi(const Glib::ustring& uri, Raul::TimeStamp q, Raul::TimeDuration d);
 
 	void set_bpm(double bpm);
 	void set_quantization(double beat_fraction);
diff --git a/src/engine/machina/JackDriver.hpp b/src/engine/machina/JackDriver.hpp
index 017d867..7fb5351 100644
--- a/src/engine/machina/JackDriver.hpp
+++ b/src/engine/machina/JackDriver.hpp
@@ -22,7 +22,7 @@
 #include <raul/JackDriver.hpp>
 #include <raul/SharedPtr.hpp>
 #include <raul/DoubleBuffer.hpp>
-#include <raul/StampedChunkRingBuffer.hpp>
+#include <raul/EventRingBuffer.hpp>
 #include <raul/Semaphore.hpp>
 #include <raul/Command.hpp>
 #include <jack/midiport.h>
@@ -56,12 +56,12 @@ public:
 
 	void set_machine(SharedPtr<Machine> machine);
 	
-	void write_event(Raul::BeatTime       time,
+	void write_event(Raul::TimeStamp      time,
 	                 size_t               size,
 	                 const unsigned char* event) throw (std::logic_error);
 	
-	void set_bpm(double bpm)                   { _bpm.set(bpm); }
-	void set_quantization(double quantization) { _quantization.set(quantization); }
+	void set_bpm(double bpm)                 { _bpm.set(bpm); }
+	void set_quantization(Raul::TimeStamp q) { _quantization.set(q); }
 
 	void stop();
 
@@ -83,12 +83,12 @@ private:
 	
 	Raul::TimeSlice _cycle_time;
 
-	Raul::DoubleBuffer<double> _bpm;
-	Raul::DoubleBuffer<double> _quantization;
+	Raul::DoubleBuffer<double>          _bpm;
+	Raul::DoubleBuffer<Raul::TimeStamp> _quantization;
 
 	Raul::Command _stop;
 
-	Raul::TickTime      _record_time;
+	Raul::TimeStamp     _record_time;
 	Raul::AtomicInt     _recording;
 	SharedPtr<Recorder> _recorder;
 };
diff --git a/src/engine/machina/LearnRequest.hpp b/src/engine/machina/LearnRequest.hpp
index f6bc60f..1d36057 100644
--- a/src/engine/machina/LearnRequest.hpp
+++ b/src/engine/machina/LearnRequest.hpp
@@ -43,10 +43,10 @@ public:
 		return ret;
 	}
 
-	void start(double q, BeatTime time)
+	void start(TimeStamp q, Raul::TimeStamp time)
 		{ _started = true; _start_time = time; _quantization = q; }
 	
-	void finish(BeatTime time);
+	void finish(TimeStamp time);
 	
 	bool started() { return _started; }
 
@@ -57,6 +57,8 @@ public:
 private:
 	LearnRequest(SharedPtr<Raul::Maid> maid, SharedPtr<Node> node)
 		: _started(false)
+		, _start_time(TimeUnit(TimeUnit::BEATS, 19200), 0, 0) // irrelevant
+		, _quantization(TimeUnit(TimeUnit::BEATS, 19200), 1, 0) // irrelevant
 		, _node(node)
 		, _enter_action(new MidiAction(4, NULL))
 		, _exit_action(new MidiAction(4, NULL))
@@ -66,8 +68,8 @@ private:
 	}
 
 	bool                  _started;
-	BeatTime              _start_time;
-	double                _quantization;
+	TimeStamp             _start_time;
+	TimeStamp             _quantization;
 	SharedPtr<Node>       _node;
 	SharedPtr<MidiAction> _enter_action;
 	SharedPtr<MidiAction> _exit_action;
diff --git a/src/engine/machina/Machine.hpp b/src/engine/machina/Machine.hpp
index 5c4df36..dae8b75 100644
--- a/src/engine/machina/Machine.hpp
+++ b/src/engine/machina/Machine.hpp
@@ -36,7 +36,7 @@ namespace Machina {
  */
 class Machine : public Raul::Stateful {
 public:
-	Machine();
+	Machine(TimeUnit unit);
 	Machine(const Machine& copy);
 
 	Machine& operator=(const Machine& other);
@@ -59,11 +59,11 @@ public:
 	void write_state(Redland::Model& model);
 
 	// Audio context
-	void      reset(Raul::BeatTime time);
-	BeatCount run(const Raul::TimeSlice& time);
+	void         reset(Raul::TimeStamp time);
+	TimeDuration run(const Raul::TimeSlice& time);
 	
 	// Any context
-	inline Raul::BeatTime time() const { return _time; }
+	inline Raul::TimeStamp time() const { return _time; }
 
 	SharedPtr<LearnRequest> pending_learn() { return _pending_learn; }
 	void clear_pending_learn()              { _pending_learn.reset(); }
@@ -89,7 +89,7 @@ private:
 
 	bool                    _is_activated;
 	bool                    _is_finished;
-	Raul::BeatTime          _time;
+	Raul::TimeStamp         _time;
 	SharedPtr<LearnRequest> _pending_learn;
 	WeakPtr<Raul::MIDISink> _sink;
 	Nodes                   _nodes;
diff --git a/src/engine/machina/MachineBuilder.hpp b/src/engine/machina/MachineBuilder.hpp
index c7b5def..58d1eb4 100644
--- a/src/engine/machina/MachineBuilder.hpp
+++ b/src/engine/machina/MachineBuilder.hpp
@@ -19,7 +19,6 @@
 #define MACHINA_MACHINEBUILDER_HPP
 
 #include <list>
-#include <raul/types.hpp>
 #include <raul/SharedPtr.hpp>
 
 namespace Machina {
@@ -31,11 +30,11 @@ class Node;
 class MachineBuilder {
 public:
 	MachineBuilder(SharedPtr<Machine> machine,
-	               Raul::BeatTime     quantization);
+	               Raul::TimeStamp    quantization);
 
-	void set_time(Raul::BeatTime time) { _time = time; }
+	void set_time(Raul::TimeStamp time) { _time = time; }
 
-	void event(Raul::BeatTime time_offset, size_t size, unsigned char* buf);
+	void event(Raul::TimeStamp time_offset, size_t size, unsigned char* buf);
 	
 	void reset();
 	void resolve();
@@ -44,26 +43,26 @@ public:
 
 private:
 	bool is_delay_node(SharedPtr<Node> node) const;
-	void set_node_duration(SharedPtr<Node> node, Raul::BeatTime d) const;
+	void set_node_duration(SharedPtr<Node> node, Raul::TimeStamp d) const;
 
 	SharedPtr<Node>
 	connect_nodes(SharedPtr<Machine> m,
-                  SharedPtr<Node>    tail, Raul::BeatTime tail_end_time,
-     	          SharedPtr<Node>    head, Raul::BeatTime head_start_time);
+                  SharedPtr<Node>    tail, Raul::TimeStamp tail_end_time,
+     	          SharedPtr<Node>    head, Raul::TimeStamp head_start_time);
 	
 	typedef std::list<SharedPtr<Node> > ActiveList;
 	ActiveList _active_nodes;
 	
-	typedef std::list<std::pair<Raul::BeatTime, SharedPtr<Node> > > PolyList;
+	typedef std::list<std::pair<Raul::TimeStamp, SharedPtr<Node> > > PolyList;
 	PolyList _poly_nodes;
 
-	Raul::BeatTime     _quantization;
-	Raul::BeatTime     _time;
+	Raul::TimeStamp    _quantization;
+	Raul::TimeStamp    _time;
 
 	SharedPtr<Machine> _machine;
 	SharedPtr<Node>    _initial_node;
 	SharedPtr<Node>    _connect_node;
-	Raul::BeatTime     _connect_node_end_time;
+	Raul::TimeStamp    _connect_node_end_time;
 };
 
 
diff --git a/src/engine/machina/MidiAction.hpp b/src/engine/machina/MidiAction.hpp
index 1a3f176..57dd242 100644
--- a/src/engine/machina/MidiAction.hpp
+++ b/src/engine/machina/MidiAction.hpp
@@ -40,7 +40,7 @@ public:
 
 	bool set_event(size_t size, const byte* event);
 
-	void execute(SharedPtr<Raul::MIDISink> driver, Raul::BeatTime time);
+	void execute(SharedPtr<Raul::MIDISink> driver, Raul::TimeStamp time);
 	
 	virtual void write_state(Redland::Model& model);
 
diff --git a/src/engine/machina/Node.hpp b/src/engine/machina/Node.hpp
index 324ec29..446db96 100644
--- a/src/engine/machina/Node.hpp
+++ b/src/engine/machina/Node.hpp
@@ -28,8 +28,9 @@
 namespace Machina {
 
 class Edge;
-using Raul::BeatCount;
-using Raul::BeatTime;
+using Raul::TimeDuration;
+using Raul::TimeStamp;
+using Raul::TimeUnit;
 
 
 /** A node is a state (as in a FSM diagram), or "note".
@@ -44,7 +45,7 @@ class Node : public Raul::Stateful {
 public:
 	typedef std::string ID;
 
-	Node(BeatCount duration=1/2.0, bool initial=false);
+	Node(TimeDuration duration, bool initial=false);
 	Node(const Node& copy);
 
 	void set_enter_action(SharedPtr<Action> action);
@@ -53,8 +54,8 @@ public:
 	SharedPtr<Action> enter_action() { return _enter_action; }
 	SharedPtr<Action> exit_action()  { return _exit_action; }
 
-	void enter(SharedPtr<Raul::MIDISink> driver, BeatTime time);
-	void exit(SharedPtr<Raul::MIDISink> driver, BeatTime time);
+	void enter(SharedPtr<Raul::MIDISink> driver, TimeStamp time);
+	void exit(SharedPtr<Raul::MIDISink> driver, TimeStamp time);
 
 	void edges_changed();
 
@@ -65,15 +66,15 @@ public:
 
 	void write_state(Redland::Model& model);
 
-	bool      is_initial() const        { return _is_initial; }
-	void      set_initial(bool i)       { _is_initial = i; }
-	bool      is_active() const         { return _is_active; }
-	BeatTime  enter_time() const        { assert(_is_active); return _enter_time; }
-	BeatTime  exit_time() const         { assert(_is_active); return _enter_time + _duration; }
-	BeatCount duration()                { return _duration; }
-	void      set_duration(BeatCount d) { _duration = d; }
-	bool      is_selector() const       { return _is_selector; }
-	void      set_selector(bool i);
+	bool         is_initial() const           { return _is_initial; }
+	void         set_initial(bool i)          { _is_initial = i; }
+	bool         is_active() const            { return _is_active; }
+	TimeStamp    enter_time() const           { assert(_is_active); return _enter_time; }
+	TimeStamp    exit_time() const            { assert(_is_active); return _enter_time + _duration; }
+	TimeDuration duration()                   { return _duration; }
+	void         set_duration(TimeDuration d) { _duration = d; }
+	bool         is_selector() const          { return _is_selector; }
+	void         set_selector(bool i);
 
 	inline bool changed()     { return _changed; }
 	inline void set_changed() { _changed = true; }
@@ -90,8 +91,8 @@ private:
 	bool              _is_initial;
 	bool              _is_selector;
 	bool              _is_active;
-	BeatTime          _enter_time; ///< valid iff _is_active
-	BeatCount         _duration;
+	TimeStamp         _enter_time; ///< valid iff _is_active
+	TimeDuration      _duration;
 	SharedPtr<Action> _enter_action;
 	SharedPtr<Action> _exit_action;
 	Edges             _edges;
diff --git a/src/engine/machina/Recorder.hpp b/src/engine/machina/Recorder.hpp
index 7938556..5afce2a 100644
--- a/src/engine/machina/Recorder.hpp
+++ b/src/engine/machina/Recorder.hpp
@@ -18,10 +18,9 @@
 #ifndef MACHINA_RECORDER_HPP
 #define MACHINA_RECORDER_HPP
 
-#include <raul/types.hpp>
 #include <raul/Slave.hpp>
 #include <raul/SharedPtr.hpp>
-#include <raul/StampedChunkRingBuffer.hpp>
+#include <raul/EventRingBuffer.hpp>
 #include "Machine.hpp"
 
 namespace Machina {
@@ -31,9 +30,9 @@ class MachineBuilder;
 
 class Recorder : public Raul::Slave {
 public:
-	Recorder(size_t buffer_size, double tick_rate, double q);
+	Recorder(size_t buffer_size, TimeUnit unit, TimeStamp q);
 
-	inline void write(Raul::TickTime time, size_t size, const unsigned char* buf) {
+	inline void write(Raul::TimeStamp time, size_t size, const unsigned char* buf) {
 		_record_buffer.write(time, size, buf);
 	}
 
@@ -42,9 +41,9 @@ public:
 private:
 	virtual void _whipped();
 	
-	double                       _tick_rate;
-	Raul::StampedChunkRingBuffer _record_buffer;
-	SharedPtr<MachineBuilder>    _builder;
+	TimeUnit                  _unit;
+	Raul::EventRingBuffer     _record_buffer;
+	SharedPtr<MachineBuilder> _builder;
 };
 
 
diff --git a/src/engine/machina/SMFDriver.hpp b/src/engine/machina/SMFDriver.hpp
index 55d76a0..73e8901 100644
--- a/src/engine/machina/SMFDriver.hpp
+++ b/src/engine/machina/SMFDriver.hpp
@@ -39,17 +39,17 @@ public:
 	SMFDriver(SharedPtr<Machine> machine = SharedPtr<Machine>());
 
 	SharedPtr<Machine> learn(const std::string& filename,
-	                         double             q=0.0,
-	                         Raul::BeatTime     max_duration=0);
+	                         Raul::TimeStamp    q,
+	                         Raul::TimeDuration max_duration);
 
 	SharedPtr<Machine> learn(const std::string& filename,
 	                         unsigned           track,
-	                         double             q=0.0,
-	                         Raul::BeatTime     max_duration=0);
+	                         Raul::TimeStamp    q,
+	                         Raul::TimeDuration max_duration);
 
-	void run(SharedPtr<Machine> machine, Raul::BeatTime max_time);
+	void run(SharedPtr<Machine> machine, Raul::TimeStamp max_time);
 	
-	void write_event(Raul::BeatTime       time,
+	void write_event(Raul::TimeStamp      time,
 	                 size_t               ev_size,
 	                 const unsigned char* ev) throw (std::logic_error)
 	{ _writer->write_event(time, ev_size, ev); }
@@ -65,8 +65,8 @@ private:
 	void learn_track(SharedPtr<MachineBuilder> builder,
 	                 Raul::SMFReader&          reader,
 	                 unsigned                  track,
-	                 double                    q,
-	                 Raul::BeatTime            max_duration=0);
+	                 Raul::TimeStamp           q,
+	                 Raul::TimeDuration        max_duration);
 };