libs/ardour/ardour/audioengine.h

   1 /*
   2   Copyright (C) 2002-2004 Paul Davis
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_audioengine_h__
  21 #define __ardour_audioengine_h__
  22
  23 #ifdef WAF_BUILD
  24 #include "libardour-config.h"
  25 #endif
  26
  27 #include <iostream>
  28 #include <list>
  29 #include <set>
  30 #include <cmath>
  31 #include <exception>
  32 #include <string>
  33
  34 #include <glibmm/threads.h>
  35
  36 #include "pbd/signals.h"
  37 #include "pbd/stacktrace.h"
  38
  39 #include "ardour/ardour.h"
  40 #include "ardour/data_type.h"
  41 #include "ardour/session_handle.h"
  42 #include "ardour/libardour_visibility.h"
  43 #include "ardour/types.h"
  44 #include "ardour/chan_count.h"
  45 #include "ardour/port_manager.h"
  46
  47 class MTDM;
  48
  49 namespace ARDOUR {
  50
  51 class InternalPort;
  52 class MidiPort;
  53 class MIDIDM;
  54 class Port;
  55 class Session;
  56 class ProcessThread;
  57 class AudioBackend;
  58 struct AudioBackendInfo;
  59
  60 class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
  61 {
  62   public:
  63
  64         static AudioEngine* create ();
  65
  66         virtual ~AudioEngine ();
  67
  68         int discover_backends();
  69         std::vector<const AudioBackendInfo*> available_backends() const;
  70         std::string current_backend_name () const;
  71         boost::shared_ptr<AudioBackend> set_default_backend ();
  72         boost::shared_ptr<AudioBackend> set_backend (const std::string&, const std::string& arg1, const std::string& arg2);
  73         boost::shared_ptr<AudioBackend> current_backend() const { return _backend; }
  74         bool setup_required () const;
  75
  76         ProcessThread* main_thread() const { return _main_thread; }
  77
  78         /* START BACKEND PROXY API
  79          *
  80          * See audio_backend.h for full documentation and semantics. These wrappers
  81          * just forward to a backend implementation.
  82          */
  83
  84         int            start (bool for_latency_measurement=false);
  85         int            stop (bool for_latency_measurement=false);
  86         int            freewheel (bool start_stop);
  87         float          get_dsp_load() const ;
  88         void           transport_start ();
  89         void           transport_stop ();
  90         TransportState transport_state ();
  91         void           transport_locate (samplepos_t pos);
  92         samplepos_t     transport_sample();
  93         samplecnt_t     sample_rate () const;
  94         pframes_t      samples_per_cycle () const;
  95         int            usecs_per_cycle () const;
  96         size_t         raw_buffer_size (DataType t);
  97         samplepos_t     sample_time ();
  98         samplepos_t     sample_time_at_cycle_start ();
  99         pframes_t      samples_since_cycle_start ();
 100         bool           get_sync_offset (pframes_t& offset) const;
 101
 102         std::string    get_last_backend_error () const { return _last_backend_error_string; }
 103
 104         int            create_process_thread (boost::function<void()> func);
 105         int            join_process_threads ();
 106         bool           in_process_thread ();
 107         uint32_t       process_thread_count ();
 108
 109         /* internal backends
 110          * -20 : main thread
 111          * -21 : additional I/O threads e.g. MIDI
 112          * -22 : client/process threads
 113          *
 114          * search for
 115          * - pbd_realtime_pthread_create
 116          * - pbd_set_thread_priority
 117          */
 118         virtual int    client_real_time_priority () { return -22; }
 119
 120         int            backend_reset_requested();
 121         void           request_backend_reset();
 122         void           request_device_list_update();
 123         void           launch_device_control_app();
 124
 125         bool           is_realtime() const;
 126
 127         // for the user which hold state_lock to check if reset operation is pending
 128         bool           is_reset_requested() const { return g_atomic_int_get(const_cast<gint*>(&_hw_reset_request_count)); }
 129
 130         int set_device_name (const std::string&);
 131         int set_sample_rate (float);
 132         int set_buffer_size (uint32_t);
 133         int set_interleaved (bool yn);
 134         int set_input_channels (uint32_t);
 135         int set_output_channels (uint32_t);
 136         int set_systemic_input_latency (uint32_t);
 137         int set_systemic_output_latency (uint32_t);
 138
 139         /* END BACKEND PROXY API */
 140
 141         bool freewheeling() const { return _freewheeling; }
 142         bool running() const { return _running; }
 143
 144         Glib::Threads::Mutex& process_lock() { return _process_lock; }
 145         Glib::Threads::RecMutex& state_lock() { return _state_lock; }
 146
 147         int request_buffer_size (pframes_t samples) {
 148                 return set_buffer_size (samples);
 149         }
 150
 151         samplecnt_t processed_samples() const { return _processed_samples; }
 152
 153         void set_session (Session *);
 154         void remove_session (); // not a replacement for SessionHandle::session_going_away()
 155         Session* session() const { return _session; }
 156
 157         void reconnect_session_routes (bool reconnect_inputs = true, bool reconnect_outputs = true);
 158
 159         class NoBackendAvailable : public std::exception {
 160             public:
 161                 virtual const char *what() const throw() { return "could not connect to engine backend"; }
 162         };
 163
 164         void split_cycle (pframes_t offset);
 165
 166         int  reset_timebase ();
 167
 168         void update_latencies ();
 169
 170         /* this signal is sent for every process() cycle while freewheeling.
 171            (the regular process() call to session->process() is not made)
 172         */
 173
 174         PBD::Signal1<void, pframes_t> Freewheel;
 175
 176         PBD::Signal0<void> Xrun;
 177
 178         /** this signal is emitted if the sample rate changes */
 179         PBD::Signal1<void, samplecnt_t> SampleRateChanged;
 180
 181         /** this signal is emitted if the buffer size changes */
 182         PBD::Signal1<void, pframes_t> BufferSizeChanged;
 183
 184         /** this signal is emitted if the device cannot operate properly */
 185         PBD::Signal0<void> DeviceError;
 186
 187         /* this signal is emitted if the device list changed */
 188
 189         PBD::Signal0<void> DeviceListChanged;
 190
 191         /* this signal is sent if the backend ever disconnects us */
 192
 193         PBD::Signal1<void,const char*> Halted;
 194
 195         /* these two are emitted when the engine itself is
 196            started and stopped
 197         */
 198
 199         PBD::Signal0<void> Running;
 200         PBD::Signal0<void> Stopped;
 201
 202         /* these two are emitted when a device reset is initiated/finished
 203          */
 204
 205         PBD::Signal0<void> DeviceResetStarted;
 206         PBD::Signal0<void> DeviceResetFinished;
 207
 208         static AudioEngine* instance() { return _instance; }
 209         static void destroy();
 210         void died ();
 211
 212         /* The backend will cause these at the appropriate time(s)
 213          */
 214         int  process_callback (pframes_t nframes);
 215         int  buffer_size_change (pframes_t nframes);
 216         int  sample_rate_change (pframes_t nframes);
 217         void freewheel_callback (bool);
 218         void timebase_callback (TransportState state, pframes_t nframes, samplepos_t pos, int new_position);
 219         int  sync_callback (TransportState state, samplepos_t position);
 220         int  port_registration_callback ();
 221         void latency_callback (bool for_playback);
 222         void halted_callback (const char* reason);
 223
 224         /* checks if current thread is properly set up for audio processing */
 225         static bool thread_initialised_for_audio_processing ();
 226
 227         /* sets up the process callback thread */
 228         static void thread_init_callback (void *);
 229
 230         /* latency measurement */
 231
 232         MTDM* mtdm() { return _mtdm; }
 233         MIDIDM* mididm() { return _mididm; }
 234
 235         int  prepare_for_latency_measurement ();
 236         int  start_latency_detection (bool);
 237         void stop_latency_detection ();
 238         void set_latency_input_port (const std::string&);
 239         void set_latency_output_port (const std::string&);
 240         uint32_t latency_signal_delay () const { return _latency_signal_latency; }
 241
 242         enum LatencyMeasurement {
 243                 MeasureNone,
 244                 MeasureAudio,
 245                 MeasureMIDI
 246         };
 247
 248         LatencyMeasurement measuring_latency () const { return _measuring_latency; }
 249
 250         /* These two are used only in builds where SILENCE_AFTER_SECONDS was
 251          * set. BecameSilent will be emitted when the audioengine goes silent.
 252          * reset_silence_countdown() can be used to reset the silence
 253          * countdown, whose duration will be reduced to half of its previous
 254          * value.
 255          */
 256
 257         PBD::Signal0<void> BecameSilent;
 258         void reset_silence_countdown ();
 259
 260         void add_pending_port_deletion (Port*);
 261
 262   private:
 263         AudioEngine ();
 264
 265         static AudioEngine*       _instance;
 266
 267         Glib::Threads::Mutex       _process_lock;
 268         Glib::Threads::RecMutex    _state_lock;
 269         Glib::Threads::Cond        session_removed;
 270         bool                       session_remove_pending;
 271         sampleoffset_t              session_removal_countdown;
 272         gain_t                     session_removal_gain;
 273         gain_t                     session_removal_gain_step;
 274         bool                      _running;
 275         bool                      _freewheeling;
 276         /// number of samples between each check for changes in monitor input
 277         samplecnt_t                 monitor_check_interval;
 278         /// time of the last monitor check in samples
 279         samplecnt_t                 last_monitor_check;
 280         /// the number of samples processed since start() was called
 281         samplecnt_t                _processed_samples;
 282         Glib::Threads::Thread*     m_meter_thread;
 283         ProcessThread*            _main_thread;
 284         MTDM*                     _mtdm;
 285         MIDIDM*                   _mididm;
 286         LatencyMeasurement        _measuring_latency;
 287         PortEngine::PortHandle    _latency_input_port;
 288         PortEngine::PortHandle    _latency_output_port;
 289         samplecnt_t                _latency_flush_samples;
 290         std::string               _latency_input_name;
 291         std::string               _latency_output_name;
 292         samplecnt_t                _latency_signal_latency;
 293         bool                      _stopped_for_latency;
 294         bool                      _started_for_latency;
 295         bool                      _in_destructor;
 296
 297         std::string               _last_backend_error_string;
 298
 299         Glib::Threads::Thread*     _hw_reset_event_thread;
 300         gint                       _hw_reset_request_count;
 301         Glib::Threads::Cond        _hw_reset_condition;
 302         Glib::Threads::Mutex       _reset_request_lock;
 303         gint                       _stop_hw_reset_processing;
 304         Glib::Threads::Thread*     _hw_devicelist_update_thread;
 305         gint                       _hw_devicelist_update_count;
 306         Glib::Threads::Cond        _hw_devicelist_update_condition;
 307         Glib::Threads::Mutex       _devicelist_update_lock;
 308         gint                       _stop_hw_devicelist_processing;
 309
 310         void start_hw_event_processing();
 311         void stop_hw_event_processing();
 312         void do_reset_backend();
 313         void do_devicelist_update();
 314
 315         typedef std::map<std::string,AudioBackendInfo*> BackendMap;
 316         BackendMap _backends;
 317         AudioBackendInfo* backend_discover (const std::string&);
 318         void drop_backend ();
 319
 320 #ifdef SILENCE_AFTER
 321         samplecnt_t _silence_countdown;
 322         uint32_t   _silence_hit_cnt;
 323 #endif
 324
 325 };
 326
 327 } // namespace ARDOUR
 328
 329 #endif /* __ardour_audioengine_h__ */