class AudioBackend;
struct AudioBackendInfo;
-class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
+class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
{
public:
ProcessThread* main_thread() const { return _main_thread; }
- /* START BACKEND PROXY API
+ /* START BACKEND PROXY API
*
* See audio_backend.h for full documentation and semantics. These wrappers
* just forward to a backend implementation.
void transport_start ();
void transport_stop ();
TransportState transport_state ();
- void transport_locate (framepos_t pos);
- framepos_t transport_frame();
- framecnt_t sample_rate () const;
+ void transport_locate (samplepos_t pos);
+ samplepos_t transport_sample();
+ samplecnt_t sample_rate () const;
pframes_t samples_per_cycle () const;
int usecs_per_cycle () const;
size_t raw_buffer_size (DataType t);
- framepos_t sample_time ();
- framepos_t sample_time_at_cycle_start ();
+ samplepos_t sample_time ();
+ samplepos_t sample_time_at_cycle_start ();
pframes_t samples_since_cycle_start ();
bool get_sync_offset (pframes_t& offset) const;
+ std::string get_last_backend_error () const { return _last_backend_error_string; }
+
int create_process_thread (boost::function<void()> func);
int join_process_threads ();
bool in_process_thread ();
return set_buffer_size (samples);
}
- framecnt_t processed_frames() const { return _processed_frames; }
-
+ samplecnt_t processed_samples() const { return _processed_samples; }
+
void set_session (Session *);
void remove_session (); // not a replacement for SessionHandle::session_going_away()
Session* session() const { return _session; }
public:
virtual const char *what() const throw() { return "could not connect to engine backend"; }
};
-
+
void split_cycle (pframes_t offset);
-
+
int reset_timebase ();
-
+
void update_latencies ();
-
+
/* this signal is sent for every process() cycle while freewheeling.
(the regular process() call to session->process() is not made)
*/
-
- PBD::Signal1<int, pframes_t> Freewheel;
-
+
+ PBD::Signal1<void, pframes_t> Freewheel;
+
PBD::Signal0<void> Xrun;
/** this signal is emitted if the sample rate changes */
- PBD::Signal1<void, framecnt_t> SampleRateChanged;
+ PBD::Signal1<void, samplecnt_t> SampleRateChanged;
/** this signal is emitted if the buffer size changes */
PBD::Signal1<void, pframes_t> BufferSizeChanged;
PBD::Signal0<void> DeviceError;
/* this signal is emitted if the device list changed */
-
+
PBD::Signal0<void> DeviceListChanged;
-
+
/* this signal is sent if the backend ever disconnects us */
-
+
PBD::Signal1<void,const char*> Halted;
-
+
/* these two are emitted when the engine itself is
started and stopped
*/
-
+
PBD::Signal0<void> Running;
PBD::Signal0<void> Stopped;
+ /* these two are emitted when a device reset is initiated/finished
+ */
+
+ PBD::Signal0<void> DeviceResetStarted;
+ PBD::Signal0<void> DeviceResetFinished;
+
static AudioEngine* instance() { return _instance; }
static void destroy();
void died ();
-
+
/* The backend will cause these at the appropriate time(s)
*/
int process_callback (pframes_t nframes);
int buffer_size_change (pframes_t nframes);
int sample_rate_change (pframes_t nframes);
void freewheel_callback (bool);
- void timebase_callback (TransportState state, pframes_t nframes, framepos_t pos, int new_position);
- int sync_callback (TransportState state, framepos_t position);
+ void timebase_callback (TransportState state, pframes_t nframes, samplepos_t pos, int new_position);
+ int sync_callback (TransportState state, samplepos_t position);
int port_registration_callback ();
void latency_callback (bool for_playback);
void halted_callback (const char* reason);
+ /* checks if current thread is properly set up for audio processing */
+ static bool thread_initialised_for_audio_processing ();
+
/* sets up the process callback thread */
static void thread_init_callback (void *);
LatencyMeasurement measuring_latency () const { return _measuring_latency; }
+ /* These two are used only in builds where SILENCE_AFTER_SECONDS was
+ * set. BecameSilent will be emitted when the audioengine goes silent.
+ * reset_silence_countdown() can be used to reset the silence
+ * countdown, whose duration will be reduced to half of its previous
+ * value.
+ */
+
+ PBD::Signal0<void> BecameSilent;
+ void reset_silence_countdown ();
+
+ void add_pending_port_deletion (Port*);
+
private:
AudioEngine ();
Glib::Threads::RecMutex _state_lock;
Glib::Threads::Cond session_removed;
bool session_remove_pending;
- frameoffset_t session_removal_countdown;
+ sampleoffset_t session_removal_countdown;
gain_t session_removal_gain;
gain_t session_removal_gain_step;
bool _running;
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;
+ /// number of samples between each check for changes in monitor input
+ samplecnt_t monitor_check_interval;
+ /// time of the last monitor check in samples
+ samplecnt_t last_monitor_check;
+ /// the number of samples processed since start() was called
+ samplecnt_t _processed_samples;
Glib::Threads::Thread* m_meter_thread;
ProcessThread* _main_thread;
MTDM* _mtdm;
LatencyMeasurement _measuring_latency;
PortEngine::PortHandle _latency_input_port;
PortEngine::PortHandle _latency_output_port;
- framecnt_t _latency_flush_frames;
+ samplecnt_t _latency_flush_samples;
std::string _latency_input_name;
std::string _latency_output_name;
- framecnt_t _latency_signal_latency;
+ samplecnt_t _latency_signal_latency;
bool _stopped_for_latency;
bool _started_for_latency;
bool _in_destructor;
+ std::string _last_backend_error_string;
+
Glib::Threads::Thread* _hw_reset_event_thread;
gint _hw_reset_request_count;
Glib::Threads::Cond _hw_reset_condition;
void do_reset_backend();
void do_devicelist_update();
- void meter_thread ();
- void start_metering_thread ();
- void stop_metering_thread ();
-
- static gint m_meter_exit;
-
typedef std::map<std::string,AudioBackendInfo*> BackendMap;
BackendMap _backends;
AudioBackendInfo* backend_discover (const std::string&);
void drop_backend ();
+
+#ifdef SILENCE_AFTER
+ samplecnt_t _silence_countdown;
+ uint32_t _silence_hit_cnt;
+#endif
+
};
-
+
} // namespace ARDOUR
#endif /* __ardour_audioengine_h__ */