use AudioEngine destructor to do necessary stuff when shutting it down, and remove...

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

diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h
index 994eda5a94c090eef3ce166ee7dd8d5715676c3b..ddffd1d5c0240341590c8363d9f6c0fff5b026eb 100644 (file)
--- a/libs/ardour/ardour/audioengine.h
+++ b/libs/ardour/ardour/audioengine.h
@@ -36,13 +36,7 @@
 #include "pbd/signals.h"
 #include "pbd/stacktrace.h"
 
-#include <jack/weakjack.h>
-#include <jack/jack.h>
-#include <jack/transport.h>
-#include <jack/thread.h>
-
 #include "ardour/ardour.h"
-
 #include "ardour/data_type.h"
 #include "ardour/session_handle.h"
 #include "ardour/types.h"
@@ -53,6 +47,8 @@
 #include <jack/session.h>
 #endif
 
+class MTDM;
+
 namespace ARDOUR {
 
 class InternalPort;
@@ -70,11 +66,12 @@ public:
     static AudioEngine* create ();
 
     virtual ~AudioEngine ();
-    
+
     int discover_backends();
     std::vector<const AudioBackendInfo*> available_backends() const;
     std::string current_backend_name () const;
-    int set_backend (const std::string&, const std::string& arg1, const std::string& arg2);
+    boost::shared_ptr<AudioBackend> set_backend (const std::string&, const std::string& arg1, const std::string& arg2);
+    boost::shared_ptr<AudioBackend> current_backend() const { return _backend; }
     bool setup_required () const;
 
     ProcessThread* main_thread() const { return _main_thread; }
@@ -103,7 +100,12 @@ public:
     pframes_t      sample_time_at_cycle_start ();
     pframes_t      samples_since_cycle_start ();
     bool           get_sync_offset (pframes_t& offset) const;
-    int            create_process_thread (boost::function<void()> func, pthread_t*, size_t stacksize);
+
+    int            create_process_thread (boost::function<void()> func);
+    int            join_process_threads ();
+    bool           in_process_thread ();
+    uint32_t       process_thread_count ();
+
     bool           is_realtime() const;
     bool           connected() const;
 
@@ -132,7 +134,8 @@ public:
     
     void set_session (Session *);
     void remove_session (); // not a replacement for SessionHandle::session_going_away()
-    
+    Session* session() const { return _session; }
+
     class NoBackendAvailable : public std::exception {
       public:
        virtual const char *what() const throw() { return "could not connect to engine backend"; }
@@ -151,12 +154,7 @@ public:
     PBD::Signal1<int, pframes_t> Freewheel;
     
     PBD::Signal0<void> Xrun;
-    
 
-#ifdef HAVE_JACK_SESSION
-    PBD::Signal1<void,jack_session_event_t *> JackSessionEvent;
-#endif
-    
     /* this signal is emitted if the sample rate changes */
     
     PBD::Signal1<void, framecnt_t> SampleRateChanged;
@@ -172,13 +170,6 @@ public:
     PBD::Signal0<void> Running;
     PBD::Signal0<void> Stopped;
 
-    /* these two are emitted as we create backends that
-       can actually be used to do stuff (e.g. register ports)
-    */
-    
-    PBD::Signal0<void> BackendAvailable;
-    PBD::Signal0<void> BackendRemoved;
-    
     static AudioEngine* instance() { return _instance; }
     static void destroy();
     void died ();
@@ -198,13 +189,21 @@ public:
     /* sets up the process callback thread */
     static void thread_init_callback (void *);
 
+    /* latency measurement */
+
+    MTDM* mtdm();
+    int  prepare_for_latency_measurement ();
+    void start_latency_detection ();
+    void stop_latency_detection ();
+    void set_latency_input_port (const std::string&);
+    void set_latency_output_port (const std::string&);
+    uint32_t latency_signal_delay () const { return _latency_signal_latency; }
+
   private:
     AudioEngine ();
 
     static AudioEngine*       _instance;
 
-    boost::shared_ptr<AudioBackend> _backend;
-
     Glib::Threads::Mutex      _process_lock;
     Glib::Threads::Cond        session_removed;
     bool                       session_remove_pending;
@@ -212,30 +211,32 @@ public:
     gain_t                     session_removal_gain;
     gain_t                     session_removal_gain_step;
     bool                      _running;
-    bool                      _has_run;
-    std::map<DataType,size_t> _raw_buffer_sizes;
+    bool                      _freewheeling;
     /// number of frames between each check for changes in monitor input
     framecnt_t                 monitor_check_interval;
     /// time of the last monitor check in frames
     framecnt_t                 last_monitor_check;
     /// the number of frames processed since start() was called
     framecnt_t                _processed_frames;
-    bool                      _freewheeling;
-    bool                      _pre_freewheel_mmc_enabled;
-    int                       _usecs_per_cycle;
-    bool                       port_remove_in_progress;
     Glib::Threads::Thread*     m_meter_thread;
     ProcessThread*            _main_thread;
-    
+    MTDM*                     _mtdm;
+    bool                      _measuring_latency;
+    PortEngine::PortHandle    _latency_input_port;
+    PortEngine::PortHandle    _latency_output_port;
+    framecnt_t                _latency_flush_frames;
+    std::string               _latency_input_name;
+    std::string               _latency_output_name;
+    framecnt_t                _latency_signal_latency;
+    bool                      _started_for_latency;
+    bool                      _in_destructor;
+
     void meter_thread ();
     void start_metering_thread ();
     void stop_metering_thread ();
     
     static gint      m_meter_exit;
     
-    void parameter_changed (const std::string&);
-    PBD::ScopedConnection config_connection;
-
     typedef std::map<std::string,AudioBackendInfo*> BackendMap;
     BackendMap _backends;
     AudioBackendInfo* backend_discover (const std::string&);