- Fix process callbakc handling during export

[ardour.git] / libs / ardour / ardour / slave.h

diff --git a/libs/ardour/ardour/slave.h b/libs/ardour/ardour/slave.h
index 672d72f7e2f0b3838e119c7595a5206cfbb6c3ed..1cc73474d78a6393169894d75856fbdfea981a76 100644 (file)
--- a/libs/ardour/ardour/slave.h
+++ b/libs/ardour/ardour/slave.h
@@ -22,13 +22,19 @@
 
 #include <vector>
 
+#include <glibmm/thread.h>
+#include <boost/signals2.hpp>
+
 #include <jack/jack.h>
 
-#include <sigc++/signal.h>
+#include "pbd/signals.h"
+
 #include "ardour/types.h"
 #include "midi++/parser.h"
 #include "midi++/types.h"
 
+class PIChaser;
+
 namespace MIDI {
        class Port;
 }
@@ -140,11 +146,18 @@ class Slave {
        virtual nframes_t resolution() const = 0;
 
        /**
-        * @return - when returning true, ARDOUR will wait for one second before transport
+        * @return - when returning true, ARDOUR will wait for seekahead_distance() before transport
         * starts rolling
         */
        virtual bool requires_seekahead () const = 0;
 
+       /**
+        * @return the number of frames that this slave wants to seek ahead. Relevant
+        * only if @func requires_seekahead() returns true.
+        */
+
+       virtual nframes64_t seekahead_distance() const { return 0; }
+
        /**
         * @return - when returning true, ARDOUR will use transport speed 1.0 no matter what
         *           the slave returns
@@ -160,6 +173,7 @@ class Slave {
 /// We need this wrapper for testability, it's just too hard to mock up a session class
 class ISlaveSessionProxy {
   public:
+       virtual ~ISlaveSessionProxy() {}
        virtual TempoMap& tempo_map()                 const   { return *((TempoMap *) 0); }
        virtual nframes_t   frame_rate()                const   { return 0; }
        virtual nframes64_t audible_frame ()            const   { return 0; }
@@ -208,7 +222,7 @@ struct SafeTime {
     }
 };
 
-class MTC_Slave : public Slave, public sigc::trackable {
+class MTC_Slave : public Slave {
   public:
        MTC_Slave (Session&, MIDI::Port&);
        ~MTC_Slave ();
@@ -222,33 +236,50 @@ class MTC_Slave : public Slave, public sigc::trackable {
 
        nframes_t resolution() const;
        bool requires_seekahead () const { return true; }
+       nframes64_t seekahead_distance() const;
+       bool give_slave_full_control_over_transport_speed() const;
 
   private:
        Session&    session;
        MIDI::Port* port;
-       std::vector<sigc::connection> connections;
+       PBD::ScopedConnectionList port_connections;
        bool        can_notify_on_unknown_rate;
-       
-       SafeTime    current;
-       double      instantaneous_speed;
-       nframes_t   mtc_frame;               /* current time */
-       nframes_t   last_inbound_frame;      /* when we got it; audio clocked */
-       MIDI::byte  last_mtc_fps_byte;
-
-       static const int32_t accumulator_size = 128;
-       double   accumulator[accumulator_size];
-       int32_t accumulator_index;
-       bool    have_first_accumulated_speed;
+       PIChaser* pic;
+
+       static const int frame_tolerance;
+
+       SafeTime       current;
+       nframes_t      mtc_frame;               /* current time */
+       nframes_t      last_inbound_frame;      /* when we got it; audio clocked */
+       MIDI::byte     last_mtc_fps_byte;
+       nframes64_t    window_begin;
+       nframes64_t    window_end;
+       nframes64_t    last_mtc_timestamp;
+       nframes64_t    last_mtc_frame;
+       bool           did_reset_tc_format;
+       TimecodeFormat saved_tc_format;
+       size_t         speed_accumulator_size;
+       double*        speed_accumulator;
+       size_t         speed_accumulator_cnt;
+       bool           have_first_speed_accumulator;
+       double         average_speed;
+       Glib::Mutex    reset_lock;
+       bool           reset_pending;
 
        void reset ();
-       void update_mtc_qtr (MIDI::Parser&);
-       void update_mtc_time (const MIDI::byte *, bool);
-       void update_mtc_status (MIDI::Parser::MTC_Status);
+       void queue_reset ();
+       void maybe_reset ();
+
+       void update_mtc_qtr (MIDI::Parser&, int, nframes_t);
+       void update_mtc_time (const MIDI::byte *, bool, nframes_t);
+       void update_mtc_status (MIDI::MTC_Status);
        void read_current (SafeTime *) const;
-       double compute_apparent_speed (nframes64_t);
+       void reset_window (nframes64_t);
+       bool outside_window (nframes64_t) const;
+       void process_apparent_speed (double);
 };
 
-class MIDIClock_Slave : public Slave, public sigc::trackable {
+class MIDIClock_Slave : public Slave {
   public:
        MIDIClock_Slave (Session&, MIDI::Port&, int ppqn = 24);
 
@@ -272,7 +303,7 @@ class MIDIClock_Slave : public Slave, public sigc::trackable {
   private:
        ISlaveSessionProxy* session;
        MIDI::Port* port;
-       std::vector<sigc::connection> connections;
+       PBD::ScopedConnectionList port_connections;
 
        /// pulses per quarter note for one MIDI clock frame (default 24)
        int         ppqn;
@@ -332,24 +363,6 @@ class MIDIClock_Slave : public Slave, public sigc::trackable {
        bool _starting;
 };
 
-class ADAT_Slave : public Slave
-{
-  public:
-       ADAT_Slave () {}
-       ~ADAT_Slave () {}
-
-       bool speed_and_position (double& speed, nframes64_t& pos) {
-               speed = 0;
-               pos = 0;
-               return false;
-       }
-
-       bool locked() const { return false; }
-       bool ok() const { return false; }
-       nframes_t resolution() const { return 1; }
-       bool requires_seekahead () const { return true; }
-};
-
 class JACK_Slave : public Slave
 {
   public: