X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Faudioengine.h;h=523a05b4c11911c0930aec6492459d6828db0178;hb=f25d9b122046d9ccf81108afc2fb466a32f9cbcc;hp=5c9317ae7b6b342c015cbda7c273636810902d64;hpb=e0aaed6d65f160c328cb8b56d7c6552ee15d65e2;p=ardour.git diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h index 5c9317ae7b..523a05b4c1 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 @@ -20,43 +20,63 @@ #ifndef __ardour_audioengine_h__ #define __ardour_audioengine_h__ +#ifdef WAF_BUILD +#include "libardour-config.h" +#endif + +#include #include #include #include #include #include -#include - #include #include "pbd/rcu.h" +#include "pbd/signals.h" #include "ardour/ardour.h" #include #include -#include "ardour/types.h" + #include "ardour/data_type.h" +#include "ardour/session_handle.h" +#include "ardour/types.h" +#include "ardour/chan_count.h" + +#ifdef HAVE_JACK_SESSION +#include +#endif namespace ARDOUR { -class Session; -class Port; class InternalPort; +class MidiPort; +class Port; +class Session; +class ProcessThread; -class AudioEngine : public sigc::trackable +class AudioEngine : public SessionHandlePtr { public: typedef std::set Ports; - AudioEngine (std::string client_name); + class disconnected_exception : public std::exception { + public: + virtual const char *what() const throw() { return "AudioEngine is disconnected"; } + }; + + AudioEngine (std::string client_name, std::string session_uuid); virtual ~AudioEngine (); - + jack_client_t* jack() const; bool connected() const { return _jack != 0; } bool is_realtime () const; + ProcessThread* main_thread() const { return _main_thread; } + std::string client_name() const { return jack_client_name; } int reconnect_to_jack (); @@ -71,86 +91,94 @@ class AudioEngine : public sigc::trackable Glib::Mutex& process_lock() { return _process_lock; } - nframes_t frame_rate(); - nframes_t frames_per_cycle(); + nframes_t frame_rate() const; + nframes_t frames_per_cycle() const; + + size_t raw_buffer_size(DataType t); int usecs_per_cycle () const { return _usecs_per_cycle; } bool get_sync_offset (nframes_t& offset) const; nframes_t frames_since_cycle_start () { - if (!_running || !_jack) return 0; - return jack_frames_since_cycle_start (_jack); + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frames_since_cycle_start (_priv_jack); } nframes_t frame_time () { - if (!_running || !_jack) return 0; - return jack_frame_time (_jack); + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_frame_time (_priv_jack); + } + + nframes_t frame_time_at_cycle_start () { + jack_client_t* _priv_jack = _jack; + if (!_running || !_priv_jack) return 0; + return jack_last_frame_time (_priv_jack); } nframes_t transport_frame () const { - if (!_running || !_jack) return 0; - return jack_get_current_transport_frame (_jack); + 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 (nframes_t); - + nframes_t set_monitor_check_interval (nframes_t); + nframes_t processed_frames() const { return _processed_frames; } - float get_cpu_load() { - if (!_running || !_jack) return 0; - return jack_cpu_load (_jack); + 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 (); + void remove_session (); // not a replacement for SessionHandle::session_going_away() class PortRegistrationFailure : public std::exception { - public: - PortRegistrationFailure (const char* why = "") { - reason = why; - } - virtual const char *what() const throw() { return reason; } - - private: - const char* reason; + public: + PortRegistrationFailure (std::string const & why = "") + : reason (why) {} + + ~PortRegistrationFailure () throw () {} + + virtual const char *what() const throw () { return reason.c_str(); } + + private: + std::string 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, 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 &); - + const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags); bool can_request_hardware_monitoring (); - uint32_t n_physical_outputs (DataType type) const; - uint32_t n_physical_inputs (DataType type) const; + ChanCount n_physical_outputs () const; + ChanCount n_physical_inputs () 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); - } - - std::string get_nth_physical_input (DataType type, uint32_t n) { - return get_nth_physical (type, n, JackPortIsOutput); - } - void update_total_latencies (); void update_total_latency (const Port&); Port *get_port_by_name (const std::string &); - Port *get_port_by_name_locked (const std::string &); enum TransportState { TransportStopped = JackTransportStopped, @@ -172,46 +200,64 @@ 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; + PBD::Signal1 Freewheel; - sigc::signal Xrun; + PBD::Signal0 Xrun; /* this signal is if JACK notifies us of a graph order event */ - sigc::signal GraphReordered; + PBD::Signal0 GraphReordered; + +#ifdef HAVE_JACK_SESSION + PBD::Signal1 JackSessionEvent; +#endif + /* this signal is emitted if the sample rate changes */ - sigc::signal SampleRateChanged; + PBD::Signal1 SampleRateChanged; /* this signal is sent if JACK ever disconnects us */ - sigc::signal Halted; + PBD::Signal1 Halted; /* these two are emitted when the engine itself is started and stopped */ - sigc::signal Running; - sigc::signal Stopped; + PBD::Signal0 Running; + PBD::Signal0 Stopped; + + /** Emitted if a JACK port is registered or unregistered */ + PBD::Signal0 PortRegisteredOrUnregistered; + + /** Emitted if a JACK port is connected or disconnected */ + PBD::Signal0 PortConnectedOrDisconnected; std::string make_port_name_relative (std::string); std::string make_port_name_non_relative (std::string); + static AudioEngine* instance() { return _instance; } + void died (); + + int create_process_thread (boost::function, pthread_t*, size_t stacksize); + private: - ARDOUR::Session* session; - jack_client_t* _jack; + static AudioEngine* _instance; + + 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; - nframes_t _frame_rate; + mutable nframes_t _buffer_size; + std::map _raw_buffer_sizes; + mutable 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 @@ -220,8 +266,7 @@ class AudioEngine : public sigc::trackable nframes_t _processed_frames; bool _freewheeling; bool _freewheel_pending; - bool _freewheel_thread_registered; - sigc::slot freewheel_action; + boost::function freewheel_action; bool reconnect_on_halt; int _usecs_per_cycle; @@ -230,35 +275,39 @@ class AudioEngine : public sigc::trackable Port *register_port (DataType type, const std::string& portname, bool input); int process_callback (nframes_t nframes); + void* process_thread (); + void finish_process_cycle (int status); 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); + ChanCount n_physical (unsigned long) const; + void get_physical (DataType, unsigned long, std::vector &); void port_registration_failure (const std::string& portname); static int _xrun_callback (void *arg); +#ifdef HAVE_JACK_SESSION + static void _session_callback (jack_session_event_t *event, void *arg); +#endif static int _graph_order_callback (void *arg); static int _process_callback (nframes_t nframes, void *arg); + static void* _process_thread (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 *); + static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *); 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 (nframes_t); int jack_sample_rate_callback (nframes_t); - static void halted (void *); + int connect_to_jack (std::string client_name, std::string session_uuid); - int connect_to_jack (std::string client_name); + static void halted (void *); + static void halted_info (jack_status_t,const char*,void *); void meter_thread (); void start_metering_thread (); @@ -266,6 +315,19 @@ class AudioEngine : public sigc::trackable Glib::Thread* m_meter_thread; static gint m_meter_exit; + + ProcessThread* _main_thread; + + struct ThreadData { + AudioEngine* engine; + boost::function f; + size_t stacksize; + + ThreadData (AudioEngine* ae, boost::function fp, size_t stacksz) + : engine (ae) , f (fp) , stacksize (stacksz) {} + }; + + static void* _start_process_thread (void*); }; } // namespace ARDOUR