X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Faudioengine.h;h=a9c414e5663745be1e29f9c4a5cef5b704d25baf;hb=afd9fc30e51c41fb42b34d74d6043c2e0e3d1a13;hp=72989abb59761b4121d9d57fbbcc244e582d2022;hpb=30c08ba655330232767554c48bda1975bfb5628c;p=ardour.git diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h index 72989abb59..a9c414e566 100644 --- a/libs/ardour/ardour/audioengine.h +++ b/libs/ardour/ardour/audioengine.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2004 Paul Davis + Copyright (C) 2002-2004 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,7 +15,6 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #ifndef __ardour_audioengine_h__ @@ -31,26 +30,34 @@ #include -#include +#include "pbd/rcu.h" + +#include "ardour/ardour.h" #include #include -#include -#include +#include "ardour/types.h" +#include "ardour/data_type.h" namespace ARDOUR { -class Session; +class InternalPort; +class MidiPort; class Port; +class Session; class AudioEngine : public sigc::trackable { public: + typedef std::set Ports; + AudioEngine (std::string client_name); virtual ~AudioEngine (); - - jack_client_t* jack() const { return _jack; } + + jack_client_t* jack() const; bool connected() const { return _jack != 0; } + bool is_realtime () const; + std::string client_name() const { return jack_client_name; } int reconnect_to_jack (); @@ -59,65 +66,87 @@ class AudioEngine : public sigc::trackable bool will_reconnect_at_halt (); void set_reconnect_at_halt (bool); - int stop (); + int stop (bool forever = false); int start (); bool running() const { return _running; } Glib::Mutex& process_lock() { return _process_lock; } - jack_nframes_t frame_rate(); - jack_nframes_t frames_per_cycle(); + nframes_t frame_rate(); + nframes_t frames_per_cycle(); + + size_t raw_buffer_size(DataType t); int usecs_per_cycle () const { return _usecs_per_cycle; } - jack_nframes_t frames_since_cycle_start () { - if (!_running || !_jack) return 0; - return jack_frames_since_cycle_start (_jack); + bool get_sync_offset (nframes_t& offset) const; + + nframes_t frames_since_cycle_start () { + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frames_since_cycle_start (_priv_jack); } - jack_nframes_t frame_time () { - if (!_running || !_jack) return 0; - return jack_frame_time (_jack); + nframes_t frame_time () { + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frame_time (_priv_jack); } - jack_nframes_t transport_frame () const { - if (!_running || !_jack) return 0; - return jack_get_current_transport_frame (_jack); + nframes_t transport_frame () const { + const jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_get_current_transport_frame (_priv_jack); } - - int request_buffer_size (jack_nframes_t); - - jack_nframes_t set_monitor_check_interval (jack_nframes_t); - - float get_cpu_load() { - if (!_running || !_jack) return 0; - return jack_cpu_load (_jack); + + int request_buffer_size (nframes_t); + + nframes_t set_monitor_check_interval (nframes_t); + nframes_t processed_frames() const { return _processed_frames; } + + float get_cpu_load() { + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_cpu_load (_priv_jack); } void set_session (Session *); void remove_session (); class PortRegistrationFailure : public std::exception { - public: - virtual const char *what() const throw() { return "failed port registration"; } + public: + PortRegistrationFailure (const char* why = "") { + reason = why; + } + virtual const char *what() const throw() { return reason; } + + private: + const char* reason; }; class NoBackendAvailable : public std::exception { - public: + public: virtual const char *what() const throw() { return "could not connect to engine backend"; } }; - Port *register_input_port (DataType type, const std::string& portname); - Port *register_output_port (DataType type, const std::string& portname); - int unregister_port (Port *); - + Port *register_input_port (DataType, const std::string& portname); + Port *register_output_port (DataType, const std::string& portname); + int unregister_port (Port &); + + void split_cycle (nframes_t offset); + int connect (const std::string& source, const std::string& destination); int disconnect (const std::string& source, const std::string& destination); - int disconnect (Port *); - + int disconnect (Port &); + const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags); - uint32_t n_physical_outputs () const; - uint32_t n_physical_inputs () const; + bool can_request_hardware_monitoring (); + + uint32_t n_physical_outputs (DataType type) const; + uint32_t n_physical_inputs (DataType type) const; + + void get_physical_outputs (DataType type, std::vector&); + void get_physical_inputs (DataType type, std::vector&); std::string get_nth_physical_output (DataType type, uint32_t n) { return get_nth_physical (type, n, JackPortIsInput); @@ -127,12 +156,11 @@ class AudioEngine : public sigc::trackable return get_nth_physical (type, n, JackPortIsOutput); } - jack_nframes_t get_port_total_latency (const Port&); void update_total_latencies (); + void update_total_latency (const Port&); - /** Caller may not delete the object pointed to by the return value - */ - Port *get_port_by_name (const std::string& name, bool keep = true); + Port *get_port_by_name (const std::string &); + Port *get_port_by_name_locked (const std::string &); enum TransportState { TransportStopped = JackTransportStopped, @@ -143,7 +171,7 @@ class AudioEngine : public sigc::trackable void transport_start (); void transport_stop (); - void transport_locate (jack_nframes_t); + void transport_locate (nframes_t); TransportState transport_state (); int reset_timebase (); @@ -154,10 +182,10 @@ class AudioEngine : public sigc::trackable bool freewheeling() const { return _freewheeling; } /* this signal is sent for every process() cycle while freewheeling. - the regular process() call to session->process() is not made. +_ the regular process() call to session->process() is not made. */ - sigc::signal Freewheel; + sigc::signal Freewheel; sigc::signal Xrun; @@ -167,7 +195,7 @@ class AudioEngine : public sigc::trackable /* this signal is emitted if the sample rate changes */ - sigc::signal SampleRateChanged; + sigc::signal SampleRateChanged; /* this signal is sent if JACK ever disconnects us */ @@ -180,67 +208,79 @@ class AudioEngine : public sigc::trackable sigc::signal Running; sigc::signal Stopped; + /* this signal is emitted if a JACK port is registered or unregistered */ + + sigc::signal PortRegisteredOrUnregistered; + std::string make_port_name_relative (std::string); std::string make_port_name_non_relative (std::string); - private: - ARDOUR::Session *session; - jack_client_t *_jack; - std::string jack_client_name; - Glib::Mutex port_lock; - Glib::Mutex _process_lock; - Glib::Mutex session_remove_lock; - Glib::Cond session_removed; - bool session_remove_pending; - bool _running; - bool _has_run; - jack_nframes_t _buffer_size; - jack_nframes_t _frame_rate; - jack_nframes_t monitor_check_interval; - jack_nframes_t last_monitor_check; - jack_nframes_t _processed_frames; - bool _freewheeling; - bool _freewheel_thread_registered; - sigc::slot freewheel_action; - bool reconnect_on_halt; - int _usecs_per_cycle; - - typedef std::set Ports; - Ports ports; + static AudioEngine* instance() { return _instance; } + void died (); - int process_callback (jack_nframes_t nframes); + private: + static AudioEngine* _instance; + + ARDOUR::Session* session; + jack_client_t* volatile _jack; /* could be reset to null by SIGPIPE or another thread */ + std::string jack_client_name; + Glib::Mutex _process_lock; + Glib::Cond session_removed; + bool session_remove_pending; + bool _running; + bool _has_run; + nframes_t _buffer_size; + std::map _raw_buffer_sizes; + nframes_t _frame_rate; + /// number of frames between each check for changes in monitor input + nframes_t monitor_check_interval; + /// time of the last monitor check in frames + nframes_t last_monitor_check; + /// the number of frames processed since start() was called + nframes_t _processed_frames; + bool _freewheeling; + bool _freewheel_pending; + bool _freewheel_thread_registered; + sigc::slot freewheel_action; + bool reconnect_on_halt; + int _usecs_per_cycle; + + SerializedRCUManager ports; + + Port *register_port (DataType type, const std::string& portname, bool input); + + int process_callback (nframes_t nframes); void remove_all_ports (); - typedef std::pair PortConnection; - typedef std::list PortConnections; - - PortConnections port_connections; - void remove_connections_for (Port*); - std::string get_nth_physical (DataType type, uint32_t n, int flags); + void port_registration_failure (const std::string& portname); + static int _xrun_callback (void *arg); static int _graph_order_callback (void *arg); - static int _process_callback (jack_nframes_t nframes, void *arg); - static int _sample_rate_callback (jack_nframes_t nframes, void *arg); - static int _bufsize_callback (jack_nframes_t nframes, void *arg); - static void _jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*); + static int _process_callback (nframes_t nframes, void *arg); + static int _sample_rate_callback (nframes_t nframes, void *arg); + static int _bufsize_callback (nframes_t nframes, void *arg); + static void _jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int, void*); static int _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg); static void _freewheel_callback (int , void *arg); + static void _registration_callback (jack_port_id_t, int, void *); - void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int); + void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int); int jack_sync_callback (jack_transport_state_t, jack_position_t*); - int jack_bufsize_callback (jack_nframes_t); - int jack_sample_rate_callback (jack_nframes_t); - - static void halted (void *); + int jack_bufsize_callback (nframes_t); + int jack_sample_rate_callback (nframes_t); int connect_to_jack (std::string client_name); + static void halted (void *); + void meter_thread (); void start_metering_thread (); - Glib::Thread* m_meter_thread; - mutable gint m_meter_exit; + void stop_metering_thread (); + + Glib::Thread* m_meter_thread; + static gint m_meter_exit; }; } // namespace ARDOUR