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 SessionHandlePtr, public PortManager
  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 (framepos_t pos);
  92         framepos_t     transport_frame();
  93         framecnt_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         framepos_t     sample_time ();
  98         framepos_t     sample_time_at_cycle_start ();
  99         pframes_t      samples_since_cycle_start ();
 100         bool           get_sync_offset (pframes_t& offset) const;
 101
 102         int            create_process_thread (boost::function<void()> func);
 103         int            join_process_threads ();
 104         bool           in_process_thread ();
 105         uint32_t       process_thread_count ();
 106
 107         void           request_backend_reset();
 108         void           request_device_list_update();
 109
 110         bool           is_realtime() const;
 111         bool           connected() const;
 112
 113         // for the user which hold state_lock to check if reset operation is pending
 114         bool           is_reset_requested() const { return g_atomic_int_get(const_cast<gint*>(&_hw_reset_request_count)); }
 115
 116         int set_device_name (const std::string&);
 117         int set_sample_rate (float);
 118         int set_buffer_size (uint32_t);
 119         int set_interleaved (bool yn);
 120         int set_input_channels (uint32_t);
 121         int set_output_channels (uint32_t);
 122         int set_systemic_input_latency (uint32_t);
 123         int set_systemic_output_latency (uint32_t);
 124
 125         /* END BACKEND PROXY API */
 126
 127         bool freewheeling() const { return _freewheeling; }
 128         bool running() const { return _running; }
 129
 130         Glib::Threads::Mutex& process_lock() { return _process_lock; }
 131         Glib::Threads::RecMutex& state_lock() { return _state_lock; }
 132
 133         int request_buffer_size (pframes_t samples) {
 134                 return set_buffer_size (samples);
 135         }
 136
 137         framecnt_t processed_frames() const { return _processed_frames; }
 138
 139         void set_session (Session *);
 140         void remove_session (); // not a replacement for SessionHandle::session_going_away()
 141         Session* session() const { return _session; }
 142
 143         void reconnect_session_routes (bool reconnect_inputs = true, bool reconnect_outputs = true);
 144
 145         class NoBackendAvailable : public std::exception {
 146             public:
 147                 virtual const char *what() const throw() { return "could not connect to engine backend"; }
 148         };
 149
 150         void split_cycle (pframes_t offset);
 151
 152         int  reset_timebase ();
 153
 154         void update_latencies ();
 155
 156         /* this signal is sent for every process() cycle while freewheeling.
 157            (the regular process() call to session->process() is not made)
 158         */
 159
 160         PBD::Signal1<int, pframes_t> Freewheel;
 161
 162         PBD::Signal0<void> Xrun;
 163
 164         /** this signal is emitted if the sample rate changes */
 165         PBD::Signal1<void, framecnt_t> SampleRateChanged;
 166
 167         /** this signal is emitted if the buffer size changes */
 168         PBD::Signal1<void, pframes_t> BufferSizeChanged;
 169
 170         /** this signal is emitted if the device cannot operate properly */
 171         PBD::Signal0<void> DeviceError;
 172
 173         /* this signal is emitted if the device list changed */
 174
 175         PBD::Signal0<void> DeviceListChanged;
 176
 177         /* this signal is sent if the backend ever disconnects us */
 178
 179         PBD::Signal1<void,const char*> Halted;
 180
 181         /* these two are emitted when the engine itself is
 182            started and stopped
 183         */
 184
 185         PBD::Signal0<void> Running;
 186         PBD::Signal0<void> Stopped;
 187
 188         static AudioEngine* instance() { return _instance; }
 189         static void destroy();
 190         void died ();
 191
 192         /* The backend will cause these at the appropriate time(s)
 193          */
 194         int  process_callback (pframes_t nframes);
 195         int  buffer_size_change (pframes_t nframes);
 196         int  sample_rate_change (pframes_t nframes);
 197         void freewheel_callback (bool);
 198         void timebase_callback (TransportState state, pframes_t nframes, framepos_t pos, int new_position);
 199         int  sync_callback (TransportState state, framepos_t position);
 200         int  port_registration_callback ();
 201         void latency_callback (bool for_playback);
 202         void halted_callback (const char* reason);
 203
 204         /* sets up the process callback thread */
 205         static void thread_init_callback (void *);
 206
 207         /* latency measurement */
 208
 209         MTDM* mtdm() { return _mtdm; }
 210         MIDIDM* mididm() { return _mididm; }
 211
 212         int  prepare_for_latency_measurement ();
 213         int  start_latency_detection (bool);
 214         void stop_latency_detection ();
 215         void set_latency_input_port (const std::string&);
 216         void set_latency_output_port (const std::string&);
 217         uint32_t latency_signal_delay () const { return _latency_signal_latency; }
 218
 219         enum LatencyMeasurement {
 220                 MeasureNone,
 221                 MeasureAudio,
 222                 MeasureMIDI
 223         };
 224
 225         LatencyMeasurement measuring_latency () const { return _measuring_latency; }
 226
 227   private:
 228         AudioEngine ();
 229
 230         static AudioEngine*       _instance;
 231
 232         Glib::Threads::Mutex       _process_lock;
 233         Glib::Threads::RecMutex    _state_lock;
 234         Glib::Threads::Cond        session_removed;
 235         bool                       session_remove_pending;
 236         frameoffset_t              session_removal_countdown;
 237         gain_t                     session_removal_gain;
 238         gain_t                     session_removal_gain_step;
 239         bool                      _running;
 240         bool                      _freewheeling;
 241         /// number of frames between each check for changes in monitor input
 242         framecnt_t                 monitor_check_interval;
 243         /// time of the last monitor check in frames
 244         framecnt_t                 last_monitor_check;
 245         /// the number of frames processed since start() was called
 246         framecnt_t                _processed_frames;
 247         Glib::Threads::Thread*     m_meter_thread;
 248         ProcessThread*            _main_thread;
 249         MTDM*                     _mtdm;
 250         MIDIDM*                   _mididm;
 251         LatencyMeasurement        _measuring_latency;
 252         PortEngine::PortHandle    _latency_input_port;
 253         PortEngine::PortHandle    _latency_output_port;
 254         framecnt_t                _latency_flush_frames;
 255         std::string               _latency_input_name;
 256         std::string               _latency_output_name;
 257         framecnt_t                _latency_signal_latency;
 258         bool                      _stopped_for_latency;
 259         bool                      _started_for_latency;
 260         bool                      _in_destructor;
 261
 262         Glib::Threads::Thread*     _hw_reset_event_thread;
 263         gint                       _hw_reset_request_count;
 264         Glib::Threads::Cond        _hw_reset_condition;
 265         Glib::Threads::Mutex       _reset_request_lock;
 266         gint                       _stop_hw_reset_processing;
 267         Glib::Threads::Thread*     _hw_devicelist_update_thread;
 268         gint                       _hw_devicelist_update_count;
 269         Glib::Threads::Cond        _hw_devicelist_update_condition;
 270         Glib::Threads::Mutex       _devicelist_update_lock;
 271         gint                       _stop_hw_devicelist_processing;
 272
 273         void start_hw_event_processing();
 274         void stop_hw_event_processing();
 275         void do_reset_backend();
 276         void do_devicelist_update();
 277
 278         void meter_thread ();
 279         void start_metering_thread ();
 280         void stop_metering_thread ();
 281
 282         static gint      m_meter_exit;
 283
 284         typedef std::map<std::string,AudioBackendInfo*> BackendMap;
 285         BackendMap _backends;
 286         AudioBackendInfo* backend_discover (const std::string&);
 287         void drop_backend ();
 288 };
 289
 290 } // namespace ARDOUR
 291
 292 #endif /* __ardour_audioengine_h__ */